diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 21385345..b0141f9d 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -48,6 +48,8 @@ These are copied into the source tree (see the path) rather than fetched.
 | [LZ4](https://github.com/lz4/lz4) | `compression/lz4/` | Yann Collet | BSD-2-Clause | [lz4.txt](licenses/lz4.txt) |
 | [HLS arbitrary-precision types](https://github.com/Xilinx/HLS_arbitrary_Precision_Types) | `fpga/include/` | Xilinx, Inc. | Apache-2.0 | [xilinx-hls-headers.txt](licenses/xilinx-hls-headers.txt) |
 | [GEMMI](https://github.com/project-gemmi/gemmi) | `gemmi_gph/` | Global Phasing Ltd. | MPL-2.0 | [gemmi.txt](licenses/gemmi.txt) |
+| [PEGTL](https://github.com/taocpp/PEGTL) | `gemmi_gph/gemmi/third_party/tao/` | Dr. Colin Hirsch and Daniel Frey | MIT | [pegtl.txt](licenses/pegtl.txt) |
+| [sajson](https://github.com/chadaustin/sajson) | `gemmi_gph/gemmi/third_party/sajson.h` | Chad Austin | MIT | [sajson.txt](licenses/sajson.txt) |
 | [traccc (ACTS)](https://github.com/acts-project/traccc) | `image_analysis/spot_finding/StrongPixelSet.cpp`, `SpotExtractorGPU.cu` | CERN, for the benefit of the ACTS project | MPL-2.0 | [traccc.txt](licenses/traccc.txt) |
 | [xbflash.qspi](https://github.com/Xilinx/XRT) | `tools/xbflash.qspi/` | Xilinx / AMD | Apache-2.0 | [xbflash-qspi.txt](licenses/xbflash-qspi.txt) |
 | [wingetopt](https://github.com/alex85k/wingetopt) | `tools/wingetopt/` | Todd C. Miller; The NetBSD Foundation | ISC AND BSD-2-Clause | [wingetopt.txt](licenses/wingetopt.txt) |
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 3666d5ca..b1bbe899 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -4,6 +4,8 @@
 This is an UNSTABLE release. It includes many experimental features, as well as many AI generated fixes. We recommend using rc.152 for production use.
 
 * The rugnux results report records how the run was invoked, what it cost and what it ran on: `COMMAND_LINE=` is the command line as one shell-ready line, `WALL_TIME=` the whole invocation in seconds, and `GPU_COUNT=` / `GPU=` how many GPUs were visible and which ones. The total wall time is also printed on stdout, next to the processing time it is slightly larger than.
+* `rugnux --model` reads an mmCIF coordinate file as well as a PDB one, gzipped or not, taking the format from the file's content rather than its name. A `.cif` model was rejected before, and the run then finished successfully with no R-free and no maps.
+* A model `rugnux --model` cannot use - unreadable, or without atoms, a unit cell or a usable space group - is reported as a `WARNING:` line in the results report instead of only in the log, so a run that was asked to validate and could not is no longer indistinguishable from one that was never asked.
 * rugnux says which GPUs it can see before it starts processing, so a machine that turns out to have none - a driver mismatch, a leftover `CUDA_VISIBLE_DEVICES` - is noticed while there is still time to stop rather than after a run that took far longer than it should have.
 * rugnux writes `<prefix>_unmerged.mtz` on every run that produces an output prefix, instead of only when asked for it with `--export-unmerged`. It is written in `--mode mx` and `--mode scale` and with `--no-merge`, alongside the merged files and replacing none of them. `--no-export-unmerged` turns it off.
 * `/start` asks the writer whether the run can be written before the detector is armed, so a run whose output file already exists, or whose output directory cannot be created, is refused up front with the writer's own message instead of failing once the detector is running. This needs the TCP image stream or the built-in HDF5 writer; the ZeroMQ stream has no way to answer and is unchanged.
diff --git a/docs/RUGNUX.md b/docs/RUGNUX.md
index 2e9e4fa9..38ed78d0 100644
--- a/docs/RUGNUX.md
+++ b/docs/RUGNUX.md
@@ -761,13 +761,20 @@ The algorithms behind both are in
 
 ## Validating against a model (`rugnux --model`)
 
-Given a PDB atomic model of the same structure, `--model model.pdb` scales the model structure
+Given an atomic model of the same structure, `--model model.pdb` scales the model structure
 factors to the merged amplitudes — fitting a flat bulk-solvent contribution and an overall
 anisotropic *B* — and reports **R-work / R-free** and the mean 2Fo-Fc density at the atom centres.
 It also writes `<prefix>_2fofc.ccp4`, `<prefix>_fofc.ccp4` and `<prefix>_maps.mtz` next to the
 merged reflections. Nothing about the model is refined; it is only re-fractionalized into the data
 cell, so a deposited model with a slightly different cell still lines up.
 
+The model may be **PDB or mmCIF**, gzipped or not, and the format is taken from the file's own
+content rather than from its name — a model downloaded as `.cif`, `.pdb`, `.ent` or with no useful
+extension at all is read the same way. A model that cannot be read, or that has no atoms, no unit
+cell or no usable space group, does not fail the run: it is logged, and the results report carries a
+`WARNING: Model validation did not run: …` line, so a run that silently produced no R-free and no
+maps cannot be mistaken for one that was never given `--model`.
+
 It is a *data-quality lens*, independent of the internal statistics: R-free measures the merged
 intensities against external truth, where CC1/2 and R<sub>meas</sub> only measure them against
 themselves. It also settles the two things merged intensities alone cannot: the enantiomorph (data
@@ -990,7 +997,7 @@ Scaling and merging:
 | `--scaling-iterations <num>` | Scaling iterations with no reference data (default: 3) |
 | `-z, --reference-mtz <file>` | Reference MTZ of the same crystal form: fixes the space group and cell, resolves the [indexing ambiguity](#the-indexing-ambiguity), hands over the R-free set and reports CC<sub>ref</sub>. Not a scale anchor |
 | `--reference-column <label>` | Reference MTZ column to use (default: auto — F-model, else IMEAN/I/…) |
-| `--model <file.pdb>` | Validate the merged intensities against this atomic model — R-work / R-free and maps (see [Validating against a model](#validating-against-a-model-rugnux-model)). It also settles the frame the reflections are written in: the enantiomorph, and the [indexing ambiguity](#the-indexing-ambiguity) where no `-z` did. For serial stills given `-C` / `-S`, the model's structure factors become the per-image reference |
+| `--model <file>` | Validate the merged intensities against this atomic model (PDB or mmCIF, gzipped or not; the format is taken from the file's content) — R-work / R-free and maps (see [Validating against a model](#validating-against-a-model-rugnux-model)). It also settles the frame the reflections are written in: the enantiomorph, and the [indexing ambiguity](#the-indexing-ambiguity) where no `-z` did. For serial stills given `-C` / `-S`, the model's structure factors become the per-image reference |
 | `--write-process-h5` | Also write the (large) `_process.h5` when merging (default: only `.mtz`/`.cif`) |
 | `--no-export-unmerged` | Do not write `<prefix>_unmerged.mtz`. It is written by default: an unmerged MTZ (POINTLESS column layout) of the integrated observations, for aimless / pointless / careless. Rotation partials are summed into one full per reflection. Intensities carry the Lorentz-polarization factor and nothing else — the partiality is not divided out and the per-image scale is not applied. Written in `--mode mx` and `--mode scale`, and with `--no-merge`. See [The unmerged export](#the-unmerged-export) |
 | `--export-unmerged-partials` | Also write `<prefix>_unmerged_partials.mtz`, the same observations with each partial as its own row (one batch per image) for the reading program to sum |
diff --git a/gemmi_gph/CMakeLists.txt b/gemmi_gph/CMakeLists.txt
index 99e8fbab..323f3e88 100644
--- a/gemmi_gph/CMakeLists.txt
+++ b/gemmi_gph/CMakeLists.txt
@@ -1,9 +1,15 @@
 # Vendored subset of GEMMI (Global Phasing), v0.7.5. A single static `gemmi` target with all
 # the compiled sources: symmetry/MTZ/XDS I/O plus the atomic-model reading and structure-factor /
 # bulk-solvent / map machinery (pdb, ccp4, calculate, eig3, resinfo, polyheur).
+#
+# read_cif/mmcif/json/mmread_gz are the mmCIF and mmJSON side of coordinate reading, so `--model`
+# takes a .cif as readily as a .pdb. They bring GEMMI's own copy of the PEGTL parser with them
+# (gemmi/third_party/tao, MIT, Colin Hirsch and Daniel Frey) - header-only, and included from
+# gemmi/cif.hpp exactly where upstream GEMMI expects it.
 ADD_LIBRARY(gemmi STATIC
         symmetry.cpp gz.cpp mtz.cpp sprintf.cpp xds_ascii.cpp
         pdb.cpp resinfo.cpp polyheur.cpp calculate.cpp eig3.cpp ccp4.cpp
+        read_cif.cpp mmcif.cpp json.cpp mmread_gz.cpp
         gemmi/cellred.hpp
         gemmi/symmetry.hpp
         gemmi/fail.hpp
diff --git a/gemmi_gph/gemmi/third_party/sajson.h b/gemmi_gph/gemmi/third_party/sajson.h
new file mode 100644
index 00000000..e51cee97
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/sajson.h
@@ -0,0 +1,2599 @@
+/*
+ * Copyright (c) 2012-2017 Chad Austin
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <assert.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <math.h>
+#include <limits.h>
+#include <algorithm>
+#include <cstdio>
+#include <limits>
+
+#ifndef SAJSON_NO_STD_STRING
+#include <string> // for convenient access to error messages and string values.
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define SAJSON_LIKELY(x) __builtin_expect(!!(x), 1)
+#define SAJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#define SAJSON_ALWAYS_INLINE __attribute__((always_inline))
+#define SAJSON_UNREACHABLE() __builtin_unreachable()
+#define SAJSON_snprintf snprintf
+#elif defined(_MSC_VER)
+#define SAJSON_LIKELY(x) x
+#define SAJSON_UNLIKELY(x) x
+#define SAJSON_ALWAYS_INLINE __forceinline
+#define SAJSON_UNREACHABLE() __assume(0)
+#if (_MSC_VER <= 1800)
+#define SAJSON_snprintf _snprintf
+#else
+#define SAJSON_snprintf snprintf
+#endif
+#else
+#define SAJSON_LIKELY(x) x
+#define SAJSON_UNLIKELY(x) x
+#define SAJSON_ALWAYS_INLINE inline
+#define SAJSON_UNREACHABLE() assert(!"unreachable")
+#define SAJSON_snprintf snprintf
+#endif
+
+/**
+ * sajson Public API
+ */
+namespace sajson {
+
+    /// Tag indicating a JSON value's type.
+    enum type: uint8_t {
+        TYPE_INTEGER = 0,
+        TYPE_DOUBLE = 1,
+        TYPE_NULL = 2,
+        TYPE_FALSE = 3,
+        TYPE_TRUE = 4,
+        TYPE_STRING = 5,
+        TYPE_ARRAY = 6,
+        TYPE_OBJECT = 7,
+    };
+    
+    namespace internal {
+        static const size_t TYPE_BITS = 3;
+        static const size_t TYPE_MASK = (1 << TYPE_BITS) - 1;
+        static const size_t VALUE_MASK = size_t(-1) >> TYPE_BITS;
+    
+        static const size_t ROOT_MARKER = VALUE_MASK;
+    
+        inline type get_element_type(size_t s) {
+            return static_cast<type>(s & TYPE_MASK);
+        }
+    
+        inline size_t get_element_value(size_t s) {
+            return s >> TYPE_BITS;
+        }
+    
+        inline size_t make_element(type t, size_t value) {
+            //assert((value & ~VALUE_MASK) == 0);
+            //value &= VALUE_MASK;
+            return static_cast<size_t>(t) | (value << TYPE_BITS);
+        }
+            
+        // This template utilizes the One Definition Rule to create global arrays in a header.
+        // This trick courtesy of Rich Geldreich's Purple JSON parser.
+        template<typename unused=void>
+        struct globals_struct {
+            static const unsigned char parse_flags[256];
+        };
+        typedef globals_struct<> globals;
+
+        // bit 0 (1) - set if: plain ASCII string character
+        // bit 1 (2) - set if: whitespace
+        // bit 4 (0x10) - set if: 0-9 e E .
+        template<typename unused>
+        const uint8_t globals_struct<unused>::parse_flags[256] = {
+         // 0    1    2    3    4    5    6    7      8    9    A    B    C    D    E    F
+            0,   0,   0,   0,   0,   0,   0,   0,     0,   2,   2,   0,   0,   2,   0,   0, // 0
+            0,   0,   0,   0,   0,   0,   0,   0,     0,   0,   0,   0,   0,   0,   0,   0, // 1
+            3,   1,   0,   1,   1,   1,   1,   1,     1,   1,   1,   1,   1,   1,   0x11,1, // 2
+            0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,  0x11,0x11,1,   1,   1,   1,   1,   1, // 3
+            1,   1,   1,   1,   1,   0x11,1,   1,     1,   1,   1,   1,   1,   1,   1,   1, // 4
+            1,   1,   1,   1,   1,   1,   1,   1,     1,   1,   1,   1,   0,   1,   1,   1, // 5
+            1,   1,   1,   1,   1,   0x11,1,   1,     1,   1,   1,   1,   1,   1,   1,   1, // 6
+            1,   1,   1,   1,   1,   1,   1,   1,     1,   1,   1,   1,   1,   1,   1,   1, // 7
+
+         // 128-255
+            0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0
+        };
+
+        inline bool is_plain_string_character(char c) {
+            //return c >= 0x20 && c <= 0x7f && c != 0x22 && c != 0x5c;
+            return (globals::parse_flags[static_cast<unsigned char>(c)] & 1) != 0;
+        }
+
+        inline bool is_whitespace(char c) {
+            //return c == '\r' || c == '\n' || c == '\t' || c == ' ';
+            return (globals::parse_flags[static_cast<unsigned char>(c)] & 2) != 0;
+        }
+
+        class allocated_buffer {
+        public:
+            allocated_buffer()
+                : memory(0)
+            {}
+
+            explicit allocated_buffer(size_t length) {
+                // throws std::bad_alloc upon allocation failure
+                void* buffer = operator new(sizeof(size_t) + length);
+                memory = static_cast<layout*>(buffer);
+                memory->refcount = 1;
+            }
+
+            allocated_buffer(const allocated_buffer& that)
+                : memory(that.memory)
+            {
+                incref();
+            }
+
+            allocated_buffer(allocated_buffer&& that)
+                : memory(that.memory)
+            {
+                that.memory = 0;
+            }
+
+            ~allocated_buffer() {
+                decref();
+            }
+
+            allocated_buffer& operator=(const allocated_buffer& that) {
+                if (this != &that) {
+                    decref();
+                    memory = that.memory;
+                    incref();
+                }
+                return *this;
+            }
+
+            allocated_buffer& operator=(allocated_buffer&& that) {
+                if (this != &that) {
+                    decref();
+                    memory = that.memory;
+                    that.memory = 0;
+                }
+                return *this;
+            }
+
+            char* get_data() const {
+                return memory ? memory->data : 0;
+            }
+
+        private:
+            void incref() const {
+                if (memory) {
+                    ++(memory->refcount);
+                }
+            }
+
+            void decref() const {
+                if (memory && --(memory->refcount) == 0) {
+                    operator delete(memory);
+                }
+            }
+
+            struct layout {
+                size_t refcount;
+                char* data;
+            };
+
+            layout* memory;
+        };
+    }
+
+    /// A simple type encoding a pointer to some memory and a length (in bytes).
+    /// Does not maintain any memory.
+    class string {
+    public:
+        string(const char* text_, size_t length)
+            : text(text_)
+            , _length(length)
+        {}
+
+        const char* data() const {
+            return text;
+        }
+
+        size_t length() const {
+            return _length;
+        }
+
+#ifndef SAJSON_NO_STD_STRING
+        std::string as_string() const {
+            return std::string(text, text + _length);
+        }
+#endif
+
+    private:
+        const char* const text;
+        const size_t _length;
+
+        string(); /*=delete*/
+    };
+
+    /// A convenient way to parse JSON from a string literal.  The string ends
+    /// at its first NUL character.
+    class literal : public string {
+    public:
+        template <size_t sz>
+        explicit literal(const char (&text_)[sz])
+            : string(text_, sz - 1)
+        {
+            static_assert(sz > 0, "!");
+        }
+    };
+
+    /// A pointer to a mutable buffer, its size in bytes, and strong ownership of any
+    /// copied memory.
+    class mutable_string_view {
+    public:
+        /// Creates an empty, zero-sized view.
+        mutable_string_view()
+            : length_(0)
+            , data(0)
+            , buffer()
+        {}
+
+        /// Given a length in bytes and a pointer, constructs a view
+        /// that does not allocate a copy of the data or maintain its life.
+        /// The given pointer must stay valid for the duration of the parse and the
+        /// resulting \ref document's life.
+        mutable_string_view(size_t length, char* data_)
+            : length_(length)
+            , data(data_)
+            , buffer()
+        {}
+
+        /// Allocates a copy of the given \ref literal string and exposes a
+        /// mutable view into it.  Throws std::bad_alloc if allocation fails.
+        mutable_string_view(const literal& s)
+            : length_(s.length())
+            , buffer(length_)
+        {
+            data = buffer.get_data();
+            memcpy(data, s.data(), length_);
+        }
+
+        /// Allocates a copy of the given \ref string and exposes a mutable view
+        /// into it.  Throws std::bad_alloc if allocation fails.
+        mutable_string_view(const string& s)
+            : length_(s.length())
+            , buffer(length_)
+        {
+            data = buffer.get_data();
+            memcpy(data, s.data(), length_);
+        }
+
+        /// Copies a mutable_string_view.  If any backing memory has been
+        /// allocated, its refcount is incremented - both views can safely
+        /// use the memory.
+        mutable_string_view(const mutable_string_view& that)
+            : length_(that.length_)
+            , data(that.data)
+            , buffer(that.buffer)
+        {}
+
+        /// Move constructor - neuters the old mutable_string_view.
+        mutable_string_view(mutable_string_view&& that)
+            : length_(that.length_)
+            , data(that.data)
+            , buffer(std::move(that.buffer))
+        {
+            that.length_ = 0;
+            that.data = 0;
+        }
+
+        mutable_string_view& operator=(mutable_string_view&& that) {
+            if (this != &that) {
+                length_ = that.length_;
+                data = that.data;
+                buffer = std::move(that.buffer);
+                that.length_ = 0;
+                that.data = 0;
+            }
+            return *this;
+        }
+
+        mutable_string_view& operator=(const mutable_string_view& that) {
+            if (this != &that) {
+                length_ = that.length_;
+                data = that.data;
+                buffer = that.buffer;
+            }
+            return *this;
+        }
+
+        size_t length() const {
+            return length_;
+        }
+
+        char* get_data() const {
+            return data;
+        }
+
+    private:
+        size_t length_;
+        char* data;
+        internal::allocated_buffer buffer; // may not be allocated
+    };
+
+    namespace internal {
+        struct object_key_record {
+            size_t key_start;
+            size_t key_end;
+            size_t value;
+        };
+
+        struct object_key_comparator {
+            object_key_comparator(const char* object_data)
+                : data(object_data)
+            {}
+
+            bool operator()(const object_key_record& lhs, const string& rhs) const {
+                const size_t lhs_length = lhs.key_end - lhs.key_start;
+                const size_t rhs_length = rhs.length();
+                if (lhs_length < rhs_length) {
+                    return true;
+                } else if (lhs_length > rhs_length) {
+                    return false;
+                }
+                return memcmp(data + lhs.key_start, rhs.data(), lhs_length) < 0;
+            }
+
+            bool operator()(const string& lhs, const object_key_record& rhs) const {
+                return !(*this)(rhs, lhs);
+            }
+
+            bool operator()(
+                const object_key_record& lhs,
+                const object_key_record& rhs
+            ) {
+                const size_t lhs_length = lhs.key_end - lhs.key_start;
+                const size_t rhs_length = rhs.key_end - rhs.key_start;
+                if (lhs_length < rhs_length) {
+                    return true;
+                } else if (lhs_length > rhs_length) {
+                    return false;
+                }
+                return memcmp(
+                    data + lhs.key_start,
+                    data + rhs.key_start,
+                    lhs_length
+                ) < 0;
+            }
+
+            const char* data;
+        };
+    }
+
+    namespace integer_storage {
+        enum {
+            word_length = 1
+        };
+
+        inline int load(const size_t* location) {
+            int value;
+            memcpy(&value, location, sizeof(value));
+            return value;
+        }
+
+        inline void store(size_t* location, int value) {
+            // NOTE: Most modern compilers optimize away this constant-size
+            // memcpy into a single instruction. If any don't, and treat
+            // punning through a union as legal, they can be special-cased.
+            static_assert(
+                sizeof(value) <= sizeof(*location),
+                "size_t must not be smaller than int");
+            memcpy(location, &value, sizeof(value));
+        }
+    }
+
+    namespace double_storage {
+        enum {
+            word_length = sizeof(double) / sizeof(size_t)
+        };
+
+        inline double load(const size_t* location) {
+            double value;
+            memcpy(&value, location, sizeof(double));
+            return value;
+        }
+
+        inline void store(size_t* location, double value) {
+            // NOTE: Most modern compilers optimize away this constant-size
+            // memcpy into a single instruction. If any don't, and treat
+            // punning through a union as legal, they can be special-cased.
+            memcpy(location, &value, sizeof(double));
+        }
+    }
+
+    /// Represents a JSON value.  First, call get_type() to check its type,
+    /// which determines which methods are available.
+    ///
+    /// Note that \ref value does not maintain any backing memory, only the
+    /// corresponding \ref document does.  It is illegal to access a \ref value
+    /// after its \ref document has been destroyed.
+    class value {
+    public:
+        /// Returns the JSON value's \ref type.
+        type get_type() const {
+            return value_type;
+        }
+
+        /// Returns the length of the object or array.
+        /// Only legal if get_type() is TYPE_ARRAY or TYPE_OBJECT.
+        size_t get_length() const {
+            assert_type_2(TYPE_ARRAY, TYPE_OBJECT);
+            return payload[0];
+        }
+
+        /// Returns the nth element of an array.  Calling with an out-of-bound
+        /// index is undefined behavior.
+        /// Only legal if get_type() is TYPE_ARRAY.
+        value get_array_element(size_t index) const {
+            using namespace internal;
+            assert_type(TYPE_ARRAY);
+            size_t element = payload[1 + index];
+            return value(get_element_type(element), payload + get_element_value(element), text);
+        }
+
+        /// Returns the nth key of an object.  Calling with an out-of-bound
+        /// index is undefined behavior.
+        /// Only legal if get_type() is TYPE_OBJECT.
+        string get_object_key(size_t index) const {
+            assert_type(TYPE_OBJECT);
+            const size_t* s = payload + 1 + index * 3;
+            return string(text + s[0], s[1] - s[0]);
+        }
+
+        /// Returns the nth value of an object.  Calling with an out-of-bound
+        /// index is undefined behavior.  Only legal if get_type() is TYPE_OBJECT.
+        value get_object_value(size_t index) const {
+            using namespace internal;
+            assert_type(TYPE_OBJECT);
+            size_t element = payload[3 + index * 3];
+            return value(get_element_type(element), payload + get_element_value(element), text);
+        }
+
+        /// Given a string key, returns the value with that key or a null value
+        /// if the key is not found.  Running time is O(lg N).
+        /// Only legal if get_type() is TYPE_OBJECT.
+        value get_value_of_key(const string& key) const {
+            assert_type(TYPE_OBJECT);
+            size_t i = find_object_key(key);
+            if (i < get_length()) {
+                return get_object_value(i);
+            } else {
+                return value(TYPE_NULL, 0, 0);
+            }
+        }
+
+        /// Given a string key, returns the index of the associated value if
+        /// one exists.  Returns get_length() if there is no such key.
+        /// Note: sajson sorts object keys, so the running time is O(lg N).
+        /// Only legal if get_type() is TYPE_OBJECT
+        size_t find_object_key(const string& key) const {
+            using namespace internal;
+            assert_type(TYPE_OBJECT);
+            const object_key_record* start = reinterpret_cast<const object_key_record*>(payload + 1);
+            const object_key_record* end = start + get_length();
+#ifdef SAJSON_UNSORTED_OBJECT_KEYS
+            for (const object_key_record* i = start; i != end; ++i)
+#else
+            const object_key_record* i = std::lower_bound(start, end, key, object_key_comparator(text));
+#endif
+            if (i != end
+                    && (i->key_end - i->key_start) == key.length()
+                    && memcmp(key.data(), text + i->key_start, key.length()) == 0) {
+                return i - start;
+            }
+            return get_length();
+        }
+
+#ifndef SAJSON_NUMBERS_AS_STRINGS
+        /// If a numeric value was parsed as a 32-bit integer, returns it.
+        /// Only legal if get_type() is TYPE_INTEGER. 
+        int get_integer_value() const {
+            assert_type(TYPE_INTEGER);
+            return integer_storage::load(payload);
+        }
+
+        /// If a numeric value was parsed as a double, returns it.
+        /// Only legal if get_type() is TYPE_DOUBLE.
+        double get_double_value() const {
+            assert_type(TYPE_DOUBLE);
+            return double_storage::load(payload);
+        }
+
+        /// Returns a numeric value as a double-precision float.
+        /// Only legal if get_type() is TYPE_INTEGER or TYPE_DOUBLE.
+        double get_number_value() const {
+            assert_type_2(TYPE_INTEGER, TYPE_DOUBLE);
+            if (get_type() == TYPE_INTEGER) {
+                return get_integer_value();
+            } else {
+                return get_double_value();
+            }
+        }
+
+        /// Returns true and writes to the output argument if the numeric value
+        /// fits in a 53-bit integer.  This is useful for timestamps and other
+        /// situations where integral values with greater than 32-bit precision
+        /// are used, as 64-bit values are not understood by all JSON
+        /// implementations or languages.
+        /// Returns false if the value is not an integer or not in range.
+        /// Only legal if get_type() is TYPE_INTEGER or TYPE_DOUBLE.
+        bool get_int53_value(int64_t* out) const {
+            // Make sure the output variable is always defined to avoid any
+            // possible situation like
+            // https://gist.github.com/chadaustin/2c249cb850619ddec05b23ca42cf7a18
+            *out = 0;
+
+            assert_type_2(TYPE_INTEGER, TYPE_DOUBLE);
+            if (get_type() == TYPE_INTEGER) {
+                *out = get_integer_value();
+                return true;
+            } else if (get_type() == TYPE_DOUBLE) {
+                double v = get_double_value();
+                if (v < -(1LL << 53) || v > (1LL << 53)) {
+                    return false;
+                }
+                int64_t as_int = static_cast<int64_t>(v);
+                if (as_int != v) {
+                    return false;
+                }
+                *out = as_int;
+                return true;
+            } else {
+                return false;
+            }
+        }
+#endif
+
+        /// Returns the length of the string.
+        /// Only legal if get_type() is TYPE_STRING.
+        size_t get_string_length() const {
+            assert_type(TYPE_STRING);
+            return payload[1] - payload[0];
+        }
+
+        /// Returns a pointer to the beginning of a string value's data.
+        /// WARNING: Calling this function and using the return value as a
+        /// C-style string (that is, without also using get_string_length())
+        /// will cause the string to appear truncated if the string has
+        /// embedded NULs.
+        /// Only legal if get_type() is TYPE_STRING.
+        const char* as_cstring() const {
+            assert_type(TYPE_STRING);
+            return text + payload[0];
+        }
+
+#ifndef SAJSON_NO_STD_STRING
+        /// Returns a string's value as a std::string.
+        /// Only legal if get_type() is TYPE_STRING.
+        std::string as_string() const {
+#ifndef SAJSON_NUMBERS_AS_STRINGS
+            assert_type(TYPE_STRING);
+#else
+            assert_type_2(TYPE_STRING, TYPE_DOUBLE);
+#endif
+            return std::string(text + payload[0], text + payload[1]);
+        }
+#endif
+
+        /// \cond INTERNAL
+        const size_t* _internal_get_payload() const {
+            return payload;
+        }
+        /// \endcond
+
+    private:
+        explicit value(type value_type_, const size_t* payload_, const char* text_)
+            : value_type(value_type_)
+            , payload(payload_)
+            , text(text_)
+        {}
+
+        void assert_type(type expected) const {
+            (void) expected;
+            assert(expected == get_type());
+        }
+
+        void assert_type_2(type e1, type e2) const {
+            (void) e1;
+            (void) e2;
+            assert(e1 == get_type() || e2 == get_type());
+        }
+
+        void assert_in_bounds(size_t i) const {
+            (void) i;
+            assert(i < get_length());
+        }
+
+        const type value_type;
+        const size_t* const payload;
+        const char* const text;
+
+        friend class document;
+    };
+
+    /// Error code indicating why parse failed.
+    enum error {
+        ERROR_NO_ERROR,
+        ERROR_OUT_OF_MEMORY,
+        ERROR_UNEXPECTED_END,
+        ERROR_MISSING_ROOT_ELEMENT,
+        ERROR_BAD_ROOT,
+        ERROR_EXPECTED_COMMA,
+        ERROR_MISSING_OBJECT_KEY,
+        ERROR_EXPECTED_COLON,
+        ERROR_EXPECTED_END_OF_INPUT,
+        ERROR_UNEXPECTED_COMMA,
+        ERROR_EXPECTED_VALUE,
+        ERROR_EXPECTED_NULL,
+        ERROR_EXPECTED_FALSE,
+        ERROR_EXPECTED_TRUE,
+        ERROR_INVALID_NUMBER,
+        ERROR_MISSING_EXPONENT,
+        ERROR_ILLEGAL_CODEPOINT,
+        ERROR_INVALID_UNICODE_ESCAPE,
+        ERROR_UNEXPECTED_END_OF_UTF16,
+        ERROR_EXPECTED_U,
+        ERROR_INVALID_UTF16_TRAIL_SURROGATE,
+        ERROR_UNKNOWN_ESCAPE,
+        ERROR_INVALID_UTF8,
+    };
+
+    namespace internal {
+        class ownership {
+        public:
+            ownership() = delete;
+            ownership(const ownership&) = delete;
+            void operator=(const ownership&) = delete;
+    
+            explicit ownership(size_t* p_)
+                : p(p_)
+            {}
+    
+            ownership(ownership&& p_)
+            : p(p_.p) {
+                p_.p = 0;
+            }
+    
+            ~ownership() {
+                delete[] p;
+            }
+    
+            bool is_valid() const {
+                return !!p;
+            }
+    
+        private:
+            size_t* p;
+        };
+
+        inline const char* get_error_text(error error_code) {
+            switch (error_code) {
+                case ERROR_NO_ERROR: return "no error";
+                case ERROR_OUT_OF_MEMORY: return  "out of memory";
+                case ERROR_UNEXPECTED_END: return  "unexpected end of input";
+                case ERROR_MISSING_ROOT_ELEMENT: return  "missing root element";
+                case ERROR_BAD_ROOT: return  "document root must be object or array";
+                case ERROR_EXPECTED_COMMA: return  "expected ,";
+                case ERROR_MISSING_OBJECT_KEY: return  "missing object key";
+                case ERROR_EXPECTED_COLON: return  "expected :";
+                case ERROR_EXPECTED_END_OF_INPUT: return  "expected end of input";
+                case ERROR_UNEXPECTED_COMMA: return  "unexpected comma";
+                case ERROR_EXPECTED_VALUE: return  "expected value";
+                case ERROR_EXPECTED_NULL: return  "expected 'null'";
+                case ERROR_EXPECTED_FALSE: return  "expected 'false'";
+                case ERROR_EXPECTED_TRUE: return  "expected 'true'";
+                case ERROR_INVALID_NUMBER: return "invalid number";
+                case ERROR_MISSING_EXPONENT: return  "missing exponent";
+                case ERROR_ILLEGAL_CODEPOINT: return  "illegal unprintable codepoint in string";
+                case ERROR_INVALID_UNICODE_ESCAPE: return  "invalid character in unicode escape";
+                case ERROR_UNEXPECTED_END_OF_UTF16: return  "unexpected end of input during UTF-16 surrogate pair";
+                case ERROR_EXPECTED_U: return  "expected \\u";
+                case ERROR_INVALID_UTF16_TRAIL_SURROGATE: return  "invalid UTF-16 trail surrogate";
+                case ERROR_UNKNOWN_ESCAPE: return  "unknown escape";
+                case ERROR_INVALID_UTF8: return  "invalid UTF-8";
+            }
+
+            SAJSON_UNREACHABLE();
+        }
+    }
+
+    /**
+     * Represents the result of a JSON parse: either is_valid() and the document
+     * contains a root value or parse error information is available.
+     *
+     * Note that the document holds a strong reference to any memory allocated:
+     * any mutable copy of the input text and any memory allocated for the
+     * AST data structure.  Thus, the document must not be deallocated while any
+     * \ref value is in use.
+     */
+    class document {
+    public:
+        document(document&& rhs)
+            : input(rhs.input)
+            , structure(std::move(rhs.structure))
+            , root_type(rhs.root_type)
+            , root(rhs.root)
+            , error_line(rhs.error_line)
+            , error_column(rhs.error_column)
+            , error_code(rhs.error_code)
+            , error_arg(rhs.error_arg)
+        {
+            // Yikes... but strcpy is okay here because formatted_error is
+            // guaranteed to be null-terminated.
+            strcpy(formatted_error_message, rhs.formatted_error_message);
+            // should rhs's fields be zeroed too?
+        }
+
+        /**
+         * Returns true if the document was parsed successfully.
+         * If true, call get_root() to access the document's root value.
+         * If false, call get_error_line(), get_error_column(), and
+         * get_error_message_as_cstring() to see why the parse failed.
+         */
+        bool is_valid() const {
+            return root_type == TYPE_ARRAY || root_type == TYPE_OBJECT;
+        }
+
+        /// If is_valid(), returns the document's root \ref value.
+        value get_root() const {
+            return value(root_type, root, input.get_data());
+        }
+
+        /// If not is_valid(), returns the one-based line number where the parse failed.
+        size_t get_error_line() const {
+            return error_line;
+        }
+
+        /// If not is_valid(), returns the one-based column number where the parse failed.
+        size_t get_error_column() const {
+            return error_column;
+        }
+
+#ifndef SAJSON_NO_STD_STRING
+        /// If not is_valid(), returns a std::string indicating why the parse failed.
+        std::string get_error_message_as_string() const {
+            return formatted_error_message;
+        }
+#endif
+
+        /// If not is_valid(), returns a null-terminated C string indicating why the parse failed.
+        const char* get_error_message_as_cstring() const {
+            return formatted_error_message;
+        }
+
+        /// \cond INTERNAL
+
+        // WARNING: Internal function which is subject to change
+        error _internal_get_error_code() const {
+            return error_code;
+        }
+
+        // WARNING: Internal function which is subject to change
+        int _internal_get_error_argument() const {
+            return error_arg;
+        }
+
+        // WARNING: Internal function which is subject to change
+        const char* _internal_get_error_text() const {
+            return internal::get_error_text(error_code);
+        }
+
+        // WARNING: Internal function exposed only for high-performance language bindings.
+        type _internal_get_root_type() const {
+            return root_type;
+        }
+
+        // WARNING: Internal function exposed only for high-performance language bindings.
+        const size_t* _internal_get_root() const {
+            return root;
+        }
+
+        // WARNING: Internal function exposed only for high-performance language bindings.
+        const mutable_string_view& _internal_get_input() const {
+            return input;
+        }
+
+        /// \endcond
+
+    private:
+        document(const document&) = delete;
+        void operator=(const document&) = delete;
+
+        explicit document(const mutable_string_view& input_, internal::ownership&& structure_, type root_type_, const size_t* root_)
+            : input(input_)
+            , structure(std::move(structure_))
+            , root_type(root_type_)
+            , root(root_)
+            , error_line(0)
+            , error_column(0)
+            , error_code(ERROR_NO_ERROR)
+            , error_arg(0)
+        {
+            formatted_error_message[0] = 0;
+        }
+
+        explicit document(const mutable_string_view& input_, size_t error_line_, size_t error_column_, const error error_code_, int error_arg_)
+            : input(input_)
+            , structure(0)
+            , root_type(TYPE_NULL)
+            , root(0)
+            , error_line(error_line_)
+            , error_column(error_column_)
+            , error_code(error_code_)
+            , error_arg(error_arg_)
+        {
+            formatted_error_message[ERROR_BUFFER_LENGTH - 1] = 0;
+            int written = has_significant_error_arg()
+                ? SAJSON_snprintf(formatted_error_message, ERROR_BUFFER_LENGTH - 1, "%s: %d", _internal_get_error_text(), error_arg)
+                : SAJSON_snprintf(formatted_error_message, ERROR_BUFFER_LENGTH - 1, "%s", _internal_get_error_text());
+            (void)written;
+            assert(written >= 0 && written < ERROR_BUFFER_LENGTH);
+        }
+
+        bool has_significant_error_arg() const {
+            return error_code == ERROR_ILLEGAL_CODEPOINT;
+        }
+
+        mutable_string_view input;
+        internal::ownership structure;
+        const type root_type;
+        const size_t* const root;
+        const size_t error_line;
+        const size_t error_column;
+        const error error_code;
+        const int error_arg;
+
+        enum { ERROR_BUFFER_LENGTH = 128 };
+        char formatted_error_message[ERROR_BUFFER_LENGTH];
+
+        template<typename AllocationStrategy, typename StringType>
+        friend document parse(const AllocationStrategy& strategy, const StringType& string);
+        template<typename Allocator>
+        friend class parser;
+    };
+
+    /// Allocation policy that allocates one large buffer guaranteed to hold the
+    /// resulting AST.  This allocation policy is the fastest since it requires
+    /// no conditionals to see if more memory must be allocated.
+    class single_allocation {
+    public:
+        /// \cond INTERNAL
+
+        class stack_head {
+        public:
+            stack_head(stack_head&& other)
+                : stack_bottom(other.stack_bottom)
+                , stack_top(other.stack_top)
+            {}
+
+            bool push(size_t element) {
+                *stack_top++ = element;
+                return true;
+            }
+
+            size_t* reserve(size_t amount, bool* success) {
+                size_t* rv = stack_top;
+                stack_top += amount;
+                *success = true;
+                return rv;
+            }
+
+            // The compiler does not see the stack_head (stored in a local)
+            // and the allocator (stored as a field) have the same stack_bottom
+            // values, so it does a bit of redundant work.
+            // So there's a microoptimization available here: introduce a type
+            // "stack_mark" and make it polymorphic on the allocator.  For
+            // single_allocation, it merely needs to be a single pointer.
+
+            void reset(size_t new_top) {
+                stack_top = stack_bottom + new_top;
+            }
+
+            size_t get_size() {
+                return stack_top - stack_bottom;
+            }
+
+            size_t* get_top() {
+                return stack_top;
+            }
+
+            size_t* get_pointer_from_offset(size_t offset) {
+                return stack_bottom + offset;
+            }
+
+        private:
+            stack_head() = delete;
+            stack_head(const stack_head&) = delete;
+            void operator=(const stack_head&) = delete;
+
+            explicit stack_head(size_t* base)
+                : stack_bottom(base)
+                , stack_top(base)
+            {}
+
+            size_t* const stack_bottom;
+            size_t* stack_top;
+
+            friend class single_allocation;
+        };
+
+        class allocator {
+        public:
+            allocator() = delete;
+            allocator(const allocator&) = delete;
+            void operator=(const allocator&) = delete;
+
+            explicit allocator(size_t* buffer, size_t input_size, bool should_deallocate_)
+                : structure(buffer)
+                , structure_end(buffer ? buffer + input_size : 0)
+                , write_cursor(structure_end)
+                , should_deallocate(should_deallocate_)
+            {}
+
+            explicit allocator(std::nullptr_t)
+                : structure(0)
+                , structure_end(0)
+                , write_cursor(0)
+                , should_deallocate(false)
+            {}
+
+            allocator(allocator&& other)
+                : structure(other.structure)
+                , structure_end(other.structure_end)
+                , write_cursor(other.write_cursor)
+                , should_deallocate(other.should_deallocate)
+            {
+                other.structure = 0;
+                other.structure_end = 0;
+                other.write_cursor = 0;
+                other.should_deallocate = false;
+            }
+
+            ~allocator() {
+                if (should_deallocate) {
+                    delete[] structure;
+                }
+            }
+
+            stack_head get_stack_head(bool* success) {
+                *success = true;
+                return stack_head(structure);
+            }
+
+            size_t get_write_offset() {
+                return structure_end - write_cursor;
+            }
+
+            size_t* get_write_pointer_of(size_t v) {
+                return structure_end - v;
+            }
+
+            size_t* reserve(size_t size, bool* success) {
+                *success = true;
+                write_cursor -= size;
+                return write_cursor;
+            }
+
+            size_t* get_ast_root() {
+                return write_cursor;
+            }
+
+            internal::ownership transfer_ownership() {
+                auto p = structure;
+                structure = 0;
+                structure_end = 0;
+                write_cursor = 0;
+                if (should_deallocate) {
+                    return internal::ownership(p);
+                } else {
+                    return internal::ownership(0);
+                }
+            }
+
+        private:
+            size_t* structure;
+            size_t* structure_end;
+            size_t* write_cursor;
+            bool should_deallocate;
+        };
+
+        /// \endcond
+
+        /// Allocate a single worst-case AST buffer with one word per byte in
+        /// the input document.
+        single_allocation()
+            : has_existing_buffer(false)
+            , existing_buffer(0)
+            , existing_buffer_size(0)
+        {}
+
+        /// Write the AST into an existing buffer.  Will fail with an out of
+        /// memory error if the buffer is not guaranteed to be big enough for
+        /// the document.  The caller must guarantee the memory is valid for
+        /// the duration of the parse and the AST traversal.
+        single_allocation(size_t* existing_buffer_, size_t size_in_words)
+            : has_existing_buffer(true)
+            , existing_buffer(existing_buffer_)
+            , existing_buffer_size(size_in_words)
+        {}
+
+        /// Convenience wrapper for single_allocation(size_t*, size_t) that
+        /// automatically infers the length of a given array.
+        template<size_t N>
+        explicit single_allocation(size_t (&existing_buffer_)[N])
+            : single_allocation(existing_buffer_, N)
+        {}
+
+        /// \cond INTERNAL
+
+        allocator make_allocator(size_t input_document_size_in_bytes, bool* succeeded) const {
+            if (has_existing_buffer) {
+                if (existing_buffer_size < input_document_size_in_bytes) {
+                    *succeeded = false;
+                    return allocator(nullptr);
+                }
+                *succeeded = true;
+                return allocator(existing_buffer, input_document_size_in_bytes, false);
+            } else {
+                size_t* buffer = new(std::nothrow) size_t[input_document_size_in_bytes];
+                if (!buffer) {
+                    *succeeded = false;
+                    return allocator(nullptr);
+                }
+                *succeeded = true;
+                return allocator(buffer, input_document_size_in_bytes, true);
+            }
+        }
+
+        /// \endcond
+
+    private:
+        bool has_existing_buffer;
+        size_t* existing_buffer;
+        size_t existing_buffer_size;
+    };
+
+    /// Allocation policy that uses dynamically-growing buffers for both the
+    /// parse stack and the AST.  This allocation policy minimizes peak memory
+    /// usage at the cost of some allocation and copying churn.
+    class dynamic_allocation {
+    public:
+        /// \cond INTERNAL
+
+        class stack_head {
+        public:
+            stack_head(stack_head&& other)
+                : stack_top(other.stack_top)
+                , stack_bottom(other.stack_bottom)
+                , stack_limit(other.stack_limit)
+            {
+                other.stack_top = 0;
+                other.stack_bottom = 0;
+                other.stack_limit = 0;
+            }
+
+            ~stack_head() {
+                delete[] stack_bottom;
+            }
+
+            bool push(size_t element) {
+                if (can_grow(1)) {
+                    *stack_top++ = element;
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            size_t* reserve(size_t amount, bool* success) {
+                if (can_grow(amount)) {
+                    size_t* rv = stack_top;
+                    stack_top += amount;
+                    *success = true;
+                    return rv;
+                } else {
+                    *success = false;
+                    return 0;
+                }
+            }
+
+            void reset(size_t new_top) {
+                stack_top = stack_bottom + new_top;
+            }
+
+            size_t get_size() {
+                return stack_top - stack_bottom;
+            }
+
+            size_t* get_top() {
+                return stack_top;
+            }
+
+            size_t* get_pointer_from_offset(size_t offset) {
+                return stack_bottom + offset;
+            }
+
+        private:
+            stack_head(const stack_head&) = delete;
+            void operator=(const stack_head&) = delete;
+
+            explicit stack_head(size_t initial_capacity, bool* success) {
+                assert(initial_capacity);
+                stack_bottom = new(std::nothrow) size_t[initial_capacity];
+                stack_top = stack_bottom;
+                if (stack_bottom) {
+                    stack_limit = stack_bottom + initial_capacity;
+                } else {
+                    stack_limit = 0;
+                }
+                *success = !!stack_bottom;
+            }
+
+            bool can_grow(size_t amount) {
+                if (SAJSON_LIKELY(amount <= static_cast<size_t>(stack_limit - stack_top))) {
+                    return true;
+                }
+
+                size_t current_size = stack_top - stack_bottom;
+                size_t old_capacity = stack_limit - stack_bottom;
+                size_t new_capacity = old_capacity * 2;
+                while (new_capacity < amount + current_size) {
+                    new_capacity *= 2;
+                }
+                size_t* new_stack = new(std::nothrow) size_t[new_capacity];
+                if (!new_stack) {
+                    stack_top = 0;
+                    stack_bottom = 0;
+                    stack_limit = 0;
+                    return false;
+                }
+
+                memcpy(new_stack, stack_bottom, current_size * sizeof(size_t));
+                delete[] stack_bottom;
+                stack_top = new_stack + current_size;
+                stack_bottom = new_stack;
+                stack_limit = stack_bottom + new_capacity;
+                return true;
+            }
+
+            size_t* stack_top; // stack grows up: stack_top >= stack_bottom
+            size_t* stack_bottom;
+            size_t* stack_limit;
+
+            friend class dynamic_allocation;
+        };
+
+        class allocator {
+        public:
+            allocator() = delete;
+            allocator(const allocator&) = delete;
+            void operator=(const allocator&) = delete;
+
+            explicit allocator(size_t* buffer_, size_t current_capacity, size_t initial_stack_capacity_)
+                : ast_buffer_bottom(buffer_)
+                , ast_buffer_top(buffer_ + current_capacity)
+                , ast_write_head(ast_buffer_top)
+                , initial_stack_capacity(initial_stack_capacity_)
+            {}
+
+            explicit allocator(std::nullptr_t)
+                : ast_buffer_bottom(0)
+                , ast_buffer_top(0)
+                , ast_write_head(0)
+                , initial_stack_capacity(0)
+            {}
+
+            allocator(allocator&& other)
+                : ast_buffer_bottom(other.ast_buffer_bottom)
+                , ast_buffer_top(other.ast_buffer_top)
+                , ast_write_head(other.ast_write_head)
+                , initial_stack_capacity(other.initial_stack_capacity)
+            {
+                other.ast_buffer_bottom = 0;
+                other.ast_buffer_top = 0;
+                other.ast_write_head = 0;
+            }
+
+            ~allocator() {
+                delete[] ast_buffer_bottom;
+            }
+
+            stack_head get_stack_head(bool* success) {
+                return stack_head(initial_stack_capacity, success);
+            }
+
+            size_t get_write_offset() {
+                return ast_buffer_top - ast_write_head;
+            }
+
+            size_t* get_write_pointer_of(size_t v) {
+                return ast_buffer_top - v;
+            }
+
+            size_t* reserve(size_t size, bool* success) {
+                if (can_grow(size)) {
+                    ast_write_head -= size;
+                    *success = true;
+                    return ast_write_head;
+                } else {
+                    *success = false;
+                    return 0;
+                }
+            }
+
+            size_t* get_ast_root() {
+                return ast_write_head;
+            }
+
+            internal::ownership transfer_ownership() {
+                auto p = ast_buffer_bottom;
+                ast_buffer_bottom = 0;
+                ast_buffer_top = 0;
+                ast_write_head = 0;
+                return internal::ownership(p);
+            }
+
+        private:
+            bool can_grow(size_t amount) {
+                if (SAJSON_LIKELY(amount <= static_cast<size_t>(ast_write_head - ast_buffer_bottom))) {
+                    return true;
+                }
+                size_t current_capacity = ast_buffer_top - ast_buffer_bottom;
+
+                size_t current_size = ast_buffer_top - ast_write_head;
+                size_t new_capacity = current_capacity * 2;
+                while (new_capacity < amount + current_size) {
+                    new_capacity *= 2;
+                }
+
+                size_t* old_buffer = ast_buffer_bottom;
+                size_t* new_buffer = new(std::nothrow) size_t[new_capacity];
+                if (!new_buffer) {
+                    ast_buffer_bottom = 0;
+                    ast_buffer_top = 0;
+                    ast_write_head = 0;
+                    return false;
+                }
+
+                size_t* old_write_head = ast_write_head;
+                ast_buffer_bottom = new_buffer;
+                ast_buffer_top = new_buffer + new_capacity;
+                ast_write_head = ast_buffer_top - current_size;
+                memcpy(ast_write_head, old_write_head, current_size * sizeof(size_t));
+                delete[] old_buffer;
+
+                return true;
+            }
+
+            size_t* ast_buffer_bottom; // base address of the ast buffer - it grows down
+            size_t* ast_buffer_top;
+            size_t* ast_write_head;
+            size_t initial_stack_capacity;
+        };
+
+        /// \endcond
+
+        /// Creates a dynamic_allocation policy with the given initial AST
+        /// and stack buffer sizes.
+        dynamic_allocation(size_t initial_ast_capacity_ = 0, size_t initial_stack_capacity_ = 0)
+            : initial_ast_capacity(initial_ast_capacity_)
+            , initial_stack_capacity(initial_stack_capacity_)
+        {}
+
+        /// \cond INTERNAL
+
+        allocator make_allocator(size_t /*input_document_size_in_bytes*/, bool* succeeded) const {
+            size_t capacity = initial_ast_capacity;
+            if (!capacity) {
+                // TODO: guess based on input document size
+                capacity = 1024;
+            }
+
+            size_t* buffer = new(std::nothrow) size_t[capacity];
+            if (!buffer) {
+                *succeeded = false;
+                return allocator(nullptr);
+            }
+
+            size_t stack_capacity = initial_stack_capacity;
+            if (!stack_capacity) {
+                stack_capacity = 256;
+            }
+
+            *succeeded = true;
+            return allocator(buffer, capacity, stack_capacity);
+        }
+    
+        /// \endcond
+
+    private:
+        size_t initial_ast_capacity;
+        size_t initial_stack_capacity;
+    };
+
+    /// Allocation policy that attempts to fit the parsed AST into an existing
+    /// memory buffer.  This allocation policy is useful when using sajson in
+    /// a zero-allocation context or when there are constraints on the amount
+    // of memory that can be used.
+    class bounded_allocation {
+    public:
+        /// \cond INTERNAL
+
+        class allocator;
+
+        class stack_head {
+        public:
+            stack_head(stack_head&& other)
+                : source_allocator(other.source_allocator)
+            {
+                other.source_allocator = 0;
+            }
+
+            bool push(size_t element) {
+                if (SAJSON_LIKELY(source_allocator->can_grow(1))) {
+                    *(source_allocator->stack_top)++ = element;
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            size_t* reserve(size_t amount, bool* success) {
+                if (SAJSON_LIKELY(source_allocator->can_grow(amount))) {
+                    size_t* rv = source_allocator->stack_top;
+                    source_allocator->stack_top += amount;
+                    *success = true;
+                    return rv;
+                } else {
+                    *success = false;
+                    return 0;
+                }
+            }
+
+            void reset(size_t new_top) {
+                source_allocator->stack_top = source_allocator->structure + new_top;
+            }
+
+            size_t get_size() {
+                return source_allocator->stack_top - source_allocator->structure;
+            }
+
+            size_t* get_top() {
+                return source_allocator->stack_top;
+            }
+
+            size_t* get_pointer_from_offset(size_t offset) {
+                return source_allocator->structure + offset;
+            }
+
+        private:
+            stack_head(const stack_head&) = delete;
+            void operator=(const stack_head&) = delete;
+
+            explicit stack_head(allocator* source_allocator_)
+                : source_allocator(source_allocator_)
+            {}
+
+            allocator* source_allocator;
+
+            friend class bounded_allocation;
+        };
+
+        class allocator {
+        public:
+            allocator() = delete;
+            allocator(const allocator&) = delete;
+            void operator=(const allocator&) = delete;
+
+            explicit allocator(size_t* existing_buffer, size_t existing_buffer_size)
+                : structure(existing_buffer)
+                , structure_end(existing_buffer + existing_buffer_size)
+                , write_cursor(structure_end)
+                , stack_top(structure)
+            {}
+
+            allocator(allocator&& other)
+                : structure(other.structure)
+                , structure_end(other.structure_end)
+                , write_cursor(other.write_cursor)
+                , stack_top(other.stack_top)
+            {
+                other.structure = 0;
+                other.structure_end = 0;
+                other.write_cursor = 0;
+                other.stack_top = 0;
+            }
+
+            stack_head get_stack_head(bool* success) {
+                *success = true;
+                return stack_head(this);
+            }
+
+            size_t get_write_offset() {
+                return structure_end - write_cursor;
+            }
+
+            size_t* get_write_pointer_of(size_t v) {
+                return structure_end - v;
+            }
+
+            size_t* reserve(size_t size, bool* success) {
+                if (can_grow(size)) {
+                    write_cursor -= size;
+                    *success = true;
+                    return write_cursor;
+                } else {
+                    *success = false;
+                    return 0;
+                }
+            }
+
+            size_t* get_ast_root() {
+                return write_cursor;
+            }
+
+            internal::ownership transfer_ownership() {
+                structure = 0;
+                structure_end = 0;
+                write_cursor = 0;
+                return internal::ownership(0);
+            }
+
+        private:
+            bool can_grow(size_t amount) {
+                // invariant: stack_top <= write_cursor
+                // thus: write_cursor - stack_top is positive
+                return static_cast<size_t>(write_cursor - stack_top) >= amount;
+            }
+
+            size_t* structure;
+            size_t* structure_end;
+            size_t* write_cursor;
+            size_t* stack_top;
+
+            friend class bounded_allocation;
+        };
+
+        /// \endcond
+
+        /// Uses an existing buffer to hold the parsed AST, if it fits.  The
+        /// specified buffer must not be deallocated until after the document
+        /// is parsed and the AST traversed.
+        bounded_allocation(size_t* existing_buffer_, size_t size_in_words)
+            : existing_buffer(existing_buffer_)
+            , existing_buffer_size(size_in_words)
+        {}
+
+        /// Convenience wrapper for bounded_allocation(size_t*, size) that
+        /// automatically infers the size of the given array.
+        template<size_t N>
+        explicit bounded_allocation(size_t (&existing_buffer_)[N])
+            : bounded_allocation(existing_buffer_, N)
+        {}
+
+        /// \cond INTERNAL
+
+        allocator make_allocator(size_t /*input_document_size_in_bytes*/, bool* succeeded) const {
+            *succeeded = true;
+            return allocator(existing_buffer, existing_buffer_size);
+        }
+
+        /// \endcond
+
+    private:
+        size_t* existing_buffer;
+        size_t existing_buffer_size;
+    };
+
+    // I thought about putting parser in the internal namespace but I don't
+    // want to indent it further...
+    /// \cond INTERNAL
+    template<typename Allocator>
+    class parser {
+    public:
+        parser(const mutable_string_view& msv, Allocator&& allocator_)
+            : input(msv)
+            , input_end(input.get_data() + input.length())
+            , allocator(std::move(allocator_))
+            , root_type(TYPE_NULL)
+            , error_line(0)
+            , error_column(0)
+        {}
+
+        document get_document() {
+            if (parse()) {
+                size_t* ast_root = allocator.get_ast_root();
+                return document(input, allocator.transfer_ownership(), root_type, ast_root);
+            } else {
+                return document(input, error_line, error_column, error_code, error_arg);
+            }
+        }
+
+    private:
+        struct error_result {
+            operator bool() const {
+                return false;
+            }
+            operator char*() const {
+                return 0;
+            }
+        };
+
+        bool at_eof(const char* p) {
+            return p == input_end;
+        }
+
+        char* skip_whitespace(char* p) {
+            // There is an opportunity to make better use of superscalar
+            // hardware here* but if someone cares about JSON parsing
+            // performance the first thing they do is minify, so prefer
+            // to optimize for code size here.
+            // * https://github.com/chadaustin/Web-Benchmarks/blob/master/json/third-party/pjson/pjson.h#L1873
+            for (;;) {
+                if (SAJSON_UNLIKELY(p == input_end)) {
+                    return 0;
+                } else if (internal::is_whitespace(*p)) {
+                    ++p;
+                } else {
+                    return p;
+                }
+            }
+        }
+
+        error_result oom(char* p) {
+            return make_error(p, ERROR_OUT_OF_MEMORY);
+        }
+
+        error_result unexpected_end() {
+            return make_error(0, ERROR_UNEXPECTED_END);
+        }
+
+        error_result unexpected_end(char* p) {
+            return make_error(p, ERROR_UNEXPECTED_END);
+        }
+
+        error_result make_error(char* p, error code, int arg = 0) {
+            if (!p) {
+                p = input_end;
+            }
+
+            error_line = 1;
+            error_column = 1;
+
+            char* c = input.get_data();
+            while (c < p) {
+                if (*c == '\r') {
+                    if (c + 1 < p && c[1] == '\n') {
+                        ++error_line;
+                        error_column = 1;
+                        ++c;
+                    } else {
+                        ++error_line;
+                        error_column = 1;
+                    }
+                } else if (*c == '\n') {
+                    ++error_line;
+                    error_column = 1;
+                } else {
+                    // TODO: count UTF-8 characters
+                    ++error_column;
+                }
+                ++c;
+            }
+
+            error_code = code;
+            error_arg = arg;
+            return error_result();
+        }
+
+        bool parse() {
+            using namespace internal;
+
+            // p points to the character currently being parsed
+            char* p = input.get_data();
+
+            bool success;
+            auto stack = allocator.get_stack_head(&success);
+            if (SAJSON_UNLIKELY(!success)) {
+                return oom(p);
+            }
+
+            p = skip_whitespace(p);
+            if (SAJSON_UNLIKELY(!p)) {
+                return make_error(p, ERROR_MISSING_ROOT_ELEMENT);
+            }
+
+            // current_base is an offset to the first element of the current structure (object or array)
+            size_t current_base = stack.get_size();
+            type current_structure_type;
+            if (*p == '[') {
+                current_structure_type = TYPE_ARRAY;
+                bool s = stack.push(make_element(current_structure_type, ROOT_MARKER));
+                if (SAJSON_UNLIKELY(!s)) {
+                    return oom(p);
+                }
+                goto array_close_or_element;
+            } else if (*p == '{') {
+                current_structure_type = TYPE_OBJECT;
+                bool s = stack.push(make_element(current_structure_type, ROOT_MARKER));
+                if (SAJSON_UNLIKELY(!s)) {
+                    return oom(p);
+                }
+                goto object_close_or_element;
+            } else {
+                return make_error(p, ERROR_BAD_ROOT);
+            }
+
+            // BEGIN STATE MACHINE
+
+            size_t pop_element; // used as an argument into the `pop` routine
+
+            if (0) { // purely for structure
+
+            // ASSUMES: byte at p SHOULD be skipped
+            array_close_or_element:
+                p = skip_whitespace(p + 1);
+                if (SAJSON_UNLIKELY(!p)) {
+                    return unexpected_end();
+                }
+                if (*p == ']') {
+                    goto pop_array;
+                } else {
+                    goto next_element;
+                }
+                SAJSON_UNREACHABLE();
+
+            // ASSUMES: byte at p SHOULD be skipped
+            object_close_or_element:
+                p = skip_whitespace(p + 1);
+                if (SAJSON_UNLIKELY(!p)) {
+                    return unexpected_end();
+                }
+                if (*p == '}') {
+                    goto pop_object;
+                } else {
+                    goto object_key;
+                }
+                SAJSON_UNREACHABLE();
+
+            // ASSUMES: byte at p SHOULD NOT be skipped
+            structure_close_or_comma:
+                p = skip_whitespace(p);
+                if (SAJSON_UNLIKELY(!p)) {
+                    return unexpected_end();
+                }
+
+                if (current_structure_type == TYPE_ARRAY) {
+                    if (*p == ']') {
+                        goto pop_array;
+                    } else {
+                        if (SAJSON_UNLIKELY(*p != ',')) {
+                            return make_error(p, ERROR_EXPECTED_COMMA);
+                        }
+                        ++p;
+                        goto next_element;
+                    }
+                } else {
+                    assert(current_structure_type == TYPE_OBJECT);
+                    if (*p == '}') {
+                        goto pop_object;
+                    } else {
+                        if (SAJSON_UNLIKELY(*p != ',')) {
+                            return make_error(p, ERROR_EXPECTED_COMMA);
+                        }
+                        ++p;
+                        goto object_key;
+                    }
+                }
+                SAJSON_UNREACHABLE();
+
+            // ASSUMES: *p == '}'
+            pop_object: {
+                ++p;
+                size_t* base_ptr = stack.get_pointer_from_offset(current_base);
+                pop_element = *base_ptr;
+                if (SAJSON_UNLIKELY(!install_object(base_ptr + 1, stack.get_top()))) {
+                    return oom(p);
+                }
+                goto pop;
+            }
+
+            // ASSUMES: *p == ']'
+            pop_array: {
+                ++p;
+                size_t* base_ptr = stack.get_pointer_from_offset(current_base);
+                pop_element = *base_ptr;
+                if (SAJSON_UNLIKELY(!install_array(base_ptr + 1, stack.get_top()))) {
+                    return oom(p);
+                }
+                goto pop;
+            }
+
+            // ASSUMES: byte at p SHOULD NOT be skipped
+            object_key: {
+                p = skip_whitespace(p);
+                if (SAJSON_UNLIKELY(!p)) {
+                    return unexpected_end();
+                }
+                if (SAJSON_UNLIKELY(*p != '"')) {
+                    return make_error(p, ERROR_MISSING_OBJECT_KEY);
+                }
+                bool success_;
+                size_t* out = stack.reserve(2, &success_);
+                if (SAJSON_UNLIKELY(!success_)) {
+                    return oom(p);
+                }
+                p = parse_string(p, out);
+                if (SAJSON_UNLIKELY(!p)) {
+                    return false;
+                }
+                p = skip_whitespace(p);
+                if (SAJSON_UNLIKELY(!p || *p != ':')) {
+                    return make_error(p, ERROR_EXPECTED_COLON);
+                }
+                ++p;
+                goto next_element;
+            }
+
+            // ASSUMES: byte at p SHOULD NOT be skipped
+            next_element:
+                p = skip_whitespace(p);
+                if (SAJSON_UNLIKELY(!p)) {
+                    return unexpected_end();
+                }
+
+                type value_type_result;
+                switch (*p) {
+                    case 0:
+                        return unexpected_end(p);
+                    case 'n':
+                        p = parse_null(p);
+                        if (!p) {
+                            return false;
+                        }
+                        value_type_result = TYPE_NULL;
+                        break;
+                    case 'f':
+                        p = parse_false(p);
+                        if (!p) {
+                            return false;
+                        }
+                        value_type_result = TYPE_FALSE;
+                        break;
+                    case 't':
+                        p = parse_true(p);
+                        if (!p) {
+                            return false;
+                        }
+                        value_type_result = TYPE_TRUE;
+                        break;
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9':
+                    case '-': {
+                        auto result = parse_number(p);
+                        p = result.first;
+                        if (!p) {
+                            return false;
+                        }
+                        value_type_result = result.second;
+                        break;
+                    }
+                    case '"': {
+                        bool success_;
+                        size_t* string_tag = allocator.reserve(2, &success_);
+                        if (SAJSON_UNLIKELY(!success_)) {
+                            return oom(p);
+                        }
+                        p = parse_string(p, string_tag);
+                        if (!p) {
+                            return false;
+                        }
+                        value_type_result = TYPE_STRING;
+                        break;
+                    }
+
+                    case '[': {
+                        size_t previous_base = current_base;
+                        current_base = stack.get_size();
+                        bool s = stack.push(make_element(current_structure_type, previous_base));
+                        if (SAJSON_UNLIKELY(!s)) {
+                            return oom(p);
+                        }
+                        current_structure_type = TYPE_ARRAY;
+                        goto array_close_or_element;
+                    }
+                    case '{': {
+                        size_t previous_base = current_base;
+                        current_base = stack.get_size();
+                        bool s = stack.push(make_element(current_structure_type, previous_base));
+                        if (SAJSON_UNLIKELY(!s)) {
+                            return oom(p);
+                        }
+                        current_structure_type = TYPE_OBJECT;
+                        goto object_close_or_element;
+                    }
+                    pop: {
+                        size_t parent = get_element_value(pop_element);
+                        if (parent == ROOT_MARKER) {
+                            root_type = current_structure_type;
+                            p = skip_whitespace(p);
+                            if (SAJSON_UNLIKELY(p)) {
+                                return make_error(p, ERROR_EXPECTED_END_OF_INPUT);
+                            }
+                            return true;
+                        }
+                        stack.reset(current_base);
+                        current_base = parent;
+                        value_type_result = current_structure_type;
+                        current_structure_type = get_element_type(pop_element);
+                        break;
+                    }
+
+                    case ',':
+                        return make_error(p, ERROR_UNEXPECTED_COMMA);
+                    default:
+                        return make_error(p, ERROR_EXPECTED_VALUE);
+                }
+
+                bool s = stack.push(make_element(
+                    value_type_result,
+                    allocator.get_write_offset()));
+                if (SAJSON_UNLIKELY(!s)) {
+                    return oom(p);
+                }
+
+                goto structure_close_or_comma;
+            }
+
+            SAJSON_UNREACHABLE();
+        }
+
+        bool has_remaining_characters(char* p, ptrdiff_t remaining) {
+            return input_end - p >= remaining;
+        }
+
+        char* parse_null(char* p) {
+            if (SAJSON_UNLIKELY(!has_remaining_characters(p, 4))) {
+                make_error(p, ERROR_UNEXPECTED_END);
+                return 0;
+            }
+            char p1 = p[1];
+            char p2 = p[2];
+            char p3 = p[3];
+            if (SAJSON_UNLIKELY(p1 != 'u' || p2 != 'l' || p3 != 'l')) {
+                make_error(p, ERROR_EXPECTED_NULL);
+                return 0;
+            }
+            return p + 4;
+        }
+
+        char* parse_false(char* p) {
+            if (SAJSON_UNLIKELY(!has_remaining_characters(p, 5))) {
+                return make_error(p, ERROR_UNEXPECTED_END);
+            }
+            char p1 = p[1];
+            char p2 = p[2];
+            char p3 = p[3];
+            char p4 = p[4];
+            if (SAJSON_UNLIKELY(p1 != 'a' || p2 != 'l' || p3 != 's' || p4 != 'e')) {
+                return make_error(p, ERROR_EXPECTED_FALSE);
+            }
+            return p + 5;
+        }
+
+        char* parse_true(char* p) {
+            if (SAJSON_UNLIKELY(!has_remaining_characters(p, 4))) {
+                return make_error(p, ERROR_UNEXPECTED_END);
+            }
+            char p1 = p[1];
+            char p2 = p[2];
+            char p3 = p[3];
+            if (SAJSON_UNLIKELY(p1 != 'r' || p2 != 'u' || p3 != 'e')) {
+                return make_error(p, ERROR_EXPECTED_TRUE);
+            }
+            return p + 4;
+        }
+
+        static double pow10(int64_t exponent) {
+            if (SAJSON_UNLIKELY(exponent > 308)) {
+                return std::numeric_limits<double>::infinity();
+            } else if (SAJSON_UNLIKELY(exponent < -323)) {
+                return 0.0;
+            }
+            static const double constants[] = {
+                1e-323,1e-322,1e-321,1e-320,1e-319,1e-318,1e-317,1e-316,1e-315,1e-314,
+                1e-313,1e-312,1e-311,1e-310,1e-309,1e-308,1e-307,1e-306,1e-305,1e-304,
+                1e-303,1e-302,1e-301,1e-300,1e-299,1e-298,1e-297,1e-296,1e-295,1e-294,
+                1e-293,1e-292,1e-291,1e-290,1e-289,1e-288,1e-287,1e-286,1e-285,1e-284,
+                1e-283,1e-282,1e-281,1e-280,1e-279,1e-278,1e-277,1e-276,1e-275,1e-274,
+                1e-273,1e-272,1e-271,1e-270,1e-269,1e-268,1e-267,1e-266,1e-265,1e-264,
+                1e-263,1e-262,1e-261,1e-260,1e-259,1e-258,1e-257,1e-256,1e-255,1e-254,
+                1e-253,1e-252,1e-251,1e-250,1e-249,1e-248,1e-247,1e-246,1e-245,1e-244,
+                1e-243,1e-242,1e-241,1e-240,1e-239,1e-238,1e-237,1e-236,1e-235,1e-234,
+                1e-233,1e-232,1e-231,1e-230,1e-229,1e-228,1e-227,1e-226,1e-225,1e-224,
+                1e-223,1e-222,1e-221,1e-220,1e-219,1e-218,1e-217,1e-216,1e-215,1e-214,
+                1e-213,1e-212,1e-211,1e-210,1e-209,1e-208,1e-207,1e-206,1e-205,1e-204,
+                1e-203,1e-202,1e-201,1e-200,1e-199,1e-198,1e-197,1e-196,1e-195,1e-194,
+                1e-193,1e-192,1e-191,1e-190,1e-189,1e-188,1e-187,1e-186,1e-185,1e-184,
+                1e-183,1e-182,1e-181,1e-180,1e-179,1e-178,1e-177,1e-176,1e-175,1e-174,
+                1e-173,1e-172,1e-171,1e-170,1e-169,1e-168,1e-167,1e-166,1e-165,1e-164,
+                1e-163,1e-162,1e-161,1e-160,1e-159,1e-158,1e-157,1e-156,1e-155,1e-154,
+                1e-153,1e-152,1e-151,1e-150,1e-149,1e-148,1e-147,1e-146,1e-145,1e-144,
+                1e-143,1e-142,1e-141,1e-140,1e-139,1e-138,1e-137,1e-136,1e-135,1e-134,
+                1e-133,1e-132,1e-131,1e-130,1e-129,1e-128,1e-127,1e-126,1e-125,1e-124,
+                1e-123,1e-122,1e-121,1e-120,1e-119,1e-118,1e-117,1e-116,1e-115,1e-114,
+                1e-113,1e-112,1e-111,1e-110,1e-109,1e-108,1e-107,1e-106,1e-105,1e-104,
+                1e-103,1e-102,1e-101,1e-100,1e-99,1e-98,1e-97,1e-96,1e-95,1e-94,1e-93,
+                1e-92,1e-91,1e-90,1e-89,1e-88,1e-87,1e-86,1e-85,1e-84,1e-83,1e-82,1e-81,
+                1e-80,1e-79,1e-78,1e-77,1e-76,1e-75,1e-74,1e-73,1e-72,1e-71,1e-70,1e-69,
+                1e-68,1e-67,1e-66,1e-65,1e-64,1e-63,1e-62,1e-61,1e-60,1e-59,1e-58,1e-57,
+                1e-56,1e-55,1e-54,1e-53,1e-52,1e-51,1e-50,1e-49,1e-48,1e-47,1e-46,1e-45,
+                1e-44,1e-43,1e-42,1e-41,1e-40,1e-39,1e-38,1e-37,1e-36,1e-35,1e-34,1e-33,
+                1e-32,1e-31,1e-30,1e-29,1e-28,1e-27,1e-26,1e-25,1e-24,1e-23,1e-22,1e-21,
+                1e-20,1e-19,1e-18,1e-17,1e-16,1e-15,1e-14,1e-13,1e-12,1e-11,1e-10,1e-9,
+                1e-8,1e-7,1e-6,1e-5,1e-4,1e-3,1e-2,1e-1,1e0,1e1,1e2,1e3,1e4,1e5,1e6,1e7,
+                1e8,1e9,1e10,1e11,1e12,1e13,1e14,1e15,1e16,1e17,1e18,1e19,1e20,1e21,
+                1e22,1e23,1e24,1e25,1e26,1e27,1e28,1e29,1e30,1e31,1e32,1e33,1e34,1e35,
+                1e36,1e37,1e38,1e39,1e40,1e41,1e42,1e43,1e44,1e45,1e46,1e47,1e48,1e49,
+                1e50,1e51,1e52,1e53,1e54,1e55,1e56,1e57,1e58,1e59,1e60,1e61,1e62,1e63,
+                1e64,1e65,1e66,1e67,1e68,1e69,1e70,1e71,1e72,1e73,1e74,1e75,1e76,1e77,
+                1e78,1e79,1e80,1e81,1e82,1e83,1e84,1e85,1e86,1e87,1e88,1e89,1e90,1e91,
+                1e92,1e93,1e94,1e95,1e96,1e97,1e98,1e99,1e100,1e101,1e102,1e103,1e104,
+                1e105,1e106,1e107,1e108,1e109,1e110,1e111,1e112,1e113,1e114,1e115,1e116,
+                1e117,1e118,1e119,1e120,1e121,1e122,1e123,1e124,1e125,1e126,1e127,1e128,
+                1e129,1e130,1e131,1e132,1e133,1e134,1e135,1e136,1e137,1e138,1e139,1e140,
+                1e141,1e142,1e143,1e144,1e145,1e146,1e147,1e148,1e149,1e150,1e151,1e152,
+                1e153,1e154,1e155,1e156,1e157,1e158,1e159,1e160,1e161,1e162,1e163,1e164,
+                1e165,1e166,1e167,1e168,1e169,1e170,1e171,1e172,1e173,1e174,1e175,1e176,
+                1e177,1e178,1e179,1e180,1e181,1e182,1e183,1e184,1e185,1e186,1e187,1e188,
+                1e189,1e190,1e191,1e192,1e193,1e194,1e195,1e196,1e197,1e198,1e199,1e200,
+                1e201,1e202,1e203,1e204,1e205,1e206,1e207,1e208,1e209,1e210,1e211,1e212,
+                1e213,1e214,1e215,1e216,1e217,1e218,1e219,1e220,1e221,1e222,1e223,1e224,
+                1e225,1e226,1e227,1e228,1e229,1e230,1e231,1e232,1e233,1e234,1e235,1e236,
+                1e237,1e238,1e239,1e240,1e241,1e242,1e243,1e244,1e245,1e246,1e247,1e248,
+                1e249,1e250,1e251,1e252,1e253,1e254,1e255,1e256,1e257,1e258,1e259,1e260,
+                1e261,1e262,1e263,1e264,1e265,1e266,1e267,1e268,1e269,1e270,1e271,1e272,
+                1e273,1e274,1e275,1e276,1e277,1e278,1e279,1e280,1e281,1e282,1e283,1e284,
+                1e285,1e286,1e287,1e288,1e289,1e290,1e291,1e292,1e293,1e294,1e295,1e296,
+                1e297,1e298,1e299,1e300,1e301,1e302,1e303,1e304,1e305,1e306,1e307,1e308
+            };
+            return constants[exponent + 323];
+        }
+
+#ifndef SAJSON_NUMBERS_AS_STRINGS
+        std::pair<char*, type> parse_number(char* p) {
+            bool negative = false;
+            if ('-' == *p) {
+                ++p;
+                negative = true;
+
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+            }
+
+            bool try_double = false;
+
+            int i = 0;
+            double d = 0.0; // gcc complains that d might be used uninitialized which isn't true. appease the warning anyway.
+            if (*p == '0') {
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+            } else {
+                unsigned char c = *p;
+                if (c < '0' || c > '9') {
+                    return std::make_pair(make_error(p, ERROR_INVALID_NUMBER), TYPE_NULL);
+                }
+
+                do {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+
+                    unsigned char digit = c - '0';
+
+                    if (SAJSON_UNLIKELY(!try_double && i > INT_MAX / 10 - 9)) {
+                        // TODO: could split this into two loops
+                        try_double = true;
+                        d = i;
+                    }
+                    if (SAJSON_UNLIKELY(try_double)) {
+                        d = 10.0 * d + digit;
+                    } else {
+                        i = 10 * i + digit;
+                    }
+
+                    c = *p;
+                } while (c >= '0' && c <= '9');
+            }
+
+            int64_t exponent = 0;
+
+            if ('.' == *p) {
+                if (!try_double) {
+                    try_double = true;
+                    d = i;
+                }
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+                char c = *p;
+                if (c < '0' || c > '9') {
+                    return std::make_pair(make_error(p, ERROR_INVALID_NUMBER), TYPE_NULL);
+                }
+
+                do {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+                    d = d * 10 + (c - '0');
+                    // One option to avoid underflow would be to clamp
+                    // to INT_MIN, but int64 subtraction is cheap and
+                    // in the absurd case of parsing 2 GB of digits
+                    // with an extremely high exponent, this will
+                    // produce accurate results.  Instead, we just
+                    // leave exponent as int64_t and it will never
+                    // underflow.
+                    --exponent;
+
+                    c = *p;
+                } while (c >= '0' && c <= '9');
+            }
+
+            char e = *p;
+            if ('e' == e || 'E' == e) {
+                if (!try_double) {
+                    try_double = true;
+                    d = i;
+                }
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+
+                bool negativeExponent = false;
+                if ('-' == *p) {
+                    negativeExponent = true;
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+                } else if ('+' == *p) {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+                }
+
+                int exp = 0;
+
+                char c = *p;
+                if (SAJSON_UNLIKELY(c < '0' || c > '9')) {
+                    return std::make_pair(make_error(p, ERROR_MISSING_EXPONENT), TYPE_NULL);
+                }
+                for (;;) {
+                    // c guaranteed to be between '0' and '9', inclusive
+                    unsigned char digit = c - '0';
+                    if (exp > (INT_MAX - digit) / 10) {
+                        // The exponent overflowed.  Keep parsing, but
+                        // it will definitely be out of range when
+                        // pow10 is called.
+                        exp = INT_MAX;
+                    } else {
+                        exp = 10 * exp + digit;
+                    }
+
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+
+                    c = *p;
+                    if (c < '0' || c > '9') {
+                        break;
+                    }
+                }
+                static_assert(-INT_MAX >= INT_MIN, "exp can be negated without loss or UB");
+                exponent += (negativeExponent ? -exp : exp);
+            }
+
+            if (exponent) {
+                assert(try_double);
+                // If d is zero but the exponent is huge, don't
+                // multiply zero by inf which gives nan.
+                if (d != 0.0) {
+                    d *= pow10(exponent);
+                }
+            }
+
+            if (negative) {
+                if (try_double) {
+                    d = -d;
+                } else {
+                    i = -i;
+                }
+            }
+            if (try_double) {
+                bool success;
+                size_t* out = allocator.reserve(double_storage::word_length, &success);
+                if (SAJSON_UNLIKELY(!success)) {
+                    return std::make_pair(oom(p), TYPE_NULL);
+                }
+                double_storage::store(out, d);
+                return std::make_pair(p, TYPE_DOUBLE);
+            } else {
+                bool success;
+                size_t* out = allocator.reserve(integer_storage::word_length, &success);
+                if (SAJSON_UNLIKELY(!success)) {
+                    return std::make_pair(oom(p), TYPE_NULL);
+                }
+                integer_storage::store(out, i);
+                return std::make_pair(p, TYPE_INTEGER);
+            }
+        }
+#else
+        std::pair<char*, type> parse_number(char* p) {
+            size_t start = p - input.get_data();
+            if ('-' == *p) {
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+            }
+            if (*p == '0') {
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+            } else {
+                unsigned char c = *p;
+                if (c < '0' || c > '9') {
+                    return std::make_pair(make_error(p, ERROR_INVALID_NUMBER), TYPE_NULL);
+                }
+
+                do {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+                    c = *p;
+                } while (c >= '0' && c <= '9');
+            }
+
+            if ('.' == *p) {
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+                char c = *p;
+                if (c < '0' || c > '9') {
+                    return std::make_pair(make_error(p, ERROR_INVALID_NUMBER), TYPE_NULL);
+                }
+
+                do {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+
+                    c = *p;
+                } while (c >= '0' && c <= '9');
+            }
+
+            char e = *p;
+            if ('e' == e || 'E' == e) {
+                ++p;
+                if (SAJSON_UNLIKELY(at_eof(p))) {
+                    return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                }
+
+                if ('-' == *p) {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+                } else if ('+' == *p) {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+                }
+
+                char c = *p;
+                if (SAJSON_UNLIKELY(c < '0' || c > '9')) {
+                    return std::make_pair(make_error(p, ERROR_MISSING_EXPONENT), TYPE_NULL);
+                }
+                for (;;) {
+                    ++p;
+                    if (SAJSON_UNLIKELY(at_eof(p))) {
+                        return std::make_pair(make_error(p, ERROR_UNEXPECTED_END), TYPE_NULL);
+                    }
+
+                    c = *p;
+                    if (c < '0' || c > '9') {
+                        break;
+                    }
+                }
+            }
+
+            bool success;
+            size_t* out = allocator.reserve(2, &success);
+            if (SAJSON_UNLIKELY(!success)) {
+                return std::make_pair(oom(p), TYPE_NULL);
+            }
+            out[0] = start;
+            out[1] = p - input.get_data();
+            return std::make_pair(p, TYPE_DOUBLE);
+        }
+#endif
+
+        bool install_array(size_t* array_base, size_t* array_end) {
+            using namespace sajson::internal;
+
+            const size_t length = array_end - array_base;
+            bool success;
+            size_t* const new_base = allocator.reserve(length + 1, &success);
+            if (SAJSON_UNLIKELY(!success)) {
+                return false;
+            }
+            size_t* out = new_base + length + 1;
+            size_t* const structure_end = allocator.get_write_pointer_of(0);
+
+            while (array_end > array_base) {
+                size_t element = *--array_end;
+                type element_type = get_element_type(element);
+                size_t element_value = get_element_value(element);
+                size_t* element_ptr = structure_end - element_value;
+                *--out = make_element(element_type, element_ptr - new_base);
+            }
+            *--out = length;
+            return true;
+        }
+
+        bool install_object(size_t* object_base, size_t* object_end) {
+            using namespace internal;
+
+            assert((object_end - object_base) % 3 == 0);
+            const size_t length_times_3 = object_end - object_base;
+#ifndef SAJSON_UNSORTED_OBJECT_KEYS
+            std::sort(
+                reinterpret_cast<object_key_record*>(object_base),
+                reinterpret_cast<object_key_record*>(object_end),
+                object_key_comparator(input.get_data()));
+#endif
+
+            bool success;
+            size_t* const new_base = allocator.reserve(length_times_3 + 1, &success);
+            if (SAJSON_UNLIKELY(!success)) {
+                return false;
+            }
+            size_t* out = new_base + length_times_3 + 1;
+            size_t* const structure_end = allocator.get_write_pointer_of(0);
+
+            while (object_end > object_base) {
+                size_t element = *--object_end;
+                type element_type = get_element_type(element);
+                size_t element_value = get_element_value(element);
+                size_t* element_ptr = structure_end - element_value;
+
+                *--out = make_element(element_type, element_ptr - new_base);
+                *--out = *--object_end;
+                *--out = *--object_end;
+            }
+            *--out = length_times_3 / 3;
+            return true;
+        }
+
+        char* parse_string(char* p, size_t* tag) {
+            using namespace internal;
+
+            ++p; // "
+            size_t start = p - input.get_data();
+            char* input_end_local = input_end;
+            while (input_end_local - p >= 4) {
+                if (!is_plain_string_character(p[0])) { goto found; }
+                if (!is_plain_string_character(p[1])) { p += 1; goto found; }
+                if (!is_plain_string_character(p[2])) { p += 2; goto found; }
+                if (!is_plain_string_character(p[3])) { p += 3; goto found; }
+                p += 4;
+            }
+            for (;;) {
+                if (SAJSON_UNLIKELY(p >= input_end_local)) {
+                    return make_error(p, ERROR_UNEXPECTED_END);
+                }
+
+                if (!is_plain_string_character(*p)) {
+                    break;
+                }
+
+                ++p;
+            }
+        found:
+            if (SAJSON_LIKELY(*p == '"')) {
+                tag[0] = start;
+                tag[1] = p - input.get_data();
+                *p = '\0';
+                return p + 1;
+            }
+
+            if (*p >= 0 && *p < 0x20) {
+                return make_error(p, ERROR_ILLEGAL_CODEPOINT, static_cast<int>(*p));
+            } else {
+                // backslash or >0x7f
+                return parse_string_slow(p, tag, start);
+            }
+        }
+
+        char* read_hex(char* p, unsigned& u) {
+            unsigned v = 0;
+            int i = 4;
+            while (i--) {
+                unsigned char c = *p++;
+                if (c >= '0' && c <= '9') {
+                    c -= '0';
+                } else if (c >= 'a' && c <= 'f') {
+                    c = c - 'a' + 10;
+                } else if (c >= 'A' && c <= 'F') {
+                    c = c - 'A' + 10;
+                } else {
+                    return make_error(p, ERROR_INVALID_UNICODE_ESCAPE);
+                }
+                v = (v << 4) + c;
+            }
+
+            u = v;
+            return p;
+        }
+
+        void write_utf8(unsigned codepoint, char*& end) {
+            if (codepoint < 0x80) {
+                *end++ = codepoint;
+            } else if (codepoint < 0x800) {
+                *end++ = 0xC0 | (codepoint >> 6);
+                *end++ = 0x80 | (codepoint & 0x3F);
+            } else if (codepoint < 0x10000) {
+                *end++ = 0xE0 | (codepoint >> 12);
+                *end++ = 0x80 | ((codepoint >> 6) & 0x3F);
+                *end++ = 0x80 | (codepoint & 0x3F);
+            } else {
+                assert(codepoint < 0x200000);
+                *end++ = 0xF0 | (codepoint >> 18);
+                *end++ = 0x80 | ((codepoint >> 12) & 0x3F);
+                *end++ = 0x80 | ((codepoint >> 6) & 0x3F);
+                *end++ = 0x80 | (codepoint & 0x3F);
+            }
+        }
+
+        char* parse_string_slow(char* p, size_t* tag, size_t start) {
+            char* end = p;
+            char* input_end_local = input_end;
+
+            for (;;) {
+                if (SAJSON_UNLIKELY(p >= input_end_local)) {
+                    return make_error(p, ERROR_UNEXPECTED_END);
+                }
+
+                if (SAJSON_UNLIKELY(*p >= 0 && *p < 0x20)) {
+                    return make_error(p, ERROR_ILLEGAL_CODEPOINT, static_cast<int>(*p));
+                }
+
+                switch (*p) {
+                    case '"':
+                        tag[0] = start;
+                        tag[1] = end - input.get_data();
+                        *end = '\0';
+                        return p + 1;
+
+                    case '\\':
+                        ++p;
+                        if (SAJSON_UNLIKELY(p >= input_end_local)) {
+                            return make_error(p, ERROR_UNEXPECTED_END);
+                        }
+
+                        char replacement;
+                        switch (*p) {
+                            case '"': replacement = '"'; goto replace;
+                            case '\\': replacement = '\\'; goto replace;
+                            case '/': replacement = '/'; goto replace;
+                            case 'b': replacement = '\b'; goto replace;
+                            case 'f': replacement = '\f'; goto replace;
+                            case 'n': replacement = '\n'; goto replace;
+                            case 'r': replacement = '\r'; goto replace;
+                            case 't': replacement = '\t'; goto replace;
+                            replace:
+                                *end++ = replacement;
+                                ++p;
+                                break;
+                            case 'u': {
+                                ++p;
+                                if (SAJSON_UNLIKELY(!has_remaining_characters(p, 4))) {
+                                    return make_error(p, ERROR_UNEXPECTED_END);
+                                }
+                                unsigned u = 0; // gcc's complaining that this could be used uninitialized. wrong.
+                                p = read_hex(p, u);
+                                if (!p) {
+                                    return 0;
+                                }
+                                if (u >= 0xD800 && u <= 0xDBFF) {
+                                    if (SAJSON_UNLIKELY(!has_remaining_characters(p, 6))) {
+                                        return make_error(p, ERROR_UNEXPECTED_END_OF_UTF16);
+                                    }
+                                    char p0 = p[0];
+                                    char p1 = p[1];
+                                    if (p0 != '\\' || p1 != 'u') {
+                                        return make_error(p, ERROR_EXPECTED_U);
+                                    }
+                                    p += 2;
+                                    unsigned v = 0; // gcc's complaining that this could be used uninitialized. wrong.
+                                    p = read_hex(p, v);
+                                    if (!p) {
+                                        return p;
+                                    }
+
+                                    if (v < 0xDC00 || v > 0xDFFF) {
+                                        return make_error(p, ERROR_INVALID_UTF16_TRAIL_SURROGATE);
+                                    }
+                                    u = 0x10000 + (((u - 0xD800) << 10) | (v - 0xDC00));
+                                }
+                                write_utf8(u, end);
+                                break;
+                            }
+                            default:
+                                return make_error(p, ERROR_UNKNOWN_ESCAPE);
+                        }
+                        break;
+
+                    default:
+                        // validate UTF-8
+                        unsigned char c0 = p[0];
+                        if (c0 < 128) {
+                            *end++ = *p++;
+                        } else if (c0 < 224) {
+                            if (SAJSON_UNLIKELY(!has_remaining_characters(p, 2))) {
+                                return unexpected_end(p);
+                            }
+                            unsigned char c1 = p[1];
+                            if (c1 < 128 || c1 >= 192) {
+                                return make_error(p + 1, ERROR_INVALID_UTF8);
+                            }
+                            end[0] = c0;
+                            end[1] = c1;
+                            end += 2;
+                            p += 2;
+                        } else if (c0 < 240) {
+                            if (SAJSON_UNLIKELY(!has_remaining_characters(p, 3))) {
+                                return unexpected_end(p);
+                            }
+                            unsigned char c1 = p[1];
+                            if (c1 < 128 || c1 >= 192) {
+                                return make_error(p + 1, ERROR_INVALID_UTF8);
+                            }
+                            unsigned char c2 = p[2];
+                            if (c2 < 128 || c2 >= 192) {
+                                return make_error(p + 2, ERROR_INVALID_UTF8);
+                            }
+                            end[0] = c0;
+                            end[1] = c1;
+                            end[2] = c2;
+                            end += 3;
+                            p += 3;
+                        } else if (c0 < 248) {
+                            if (SAJSON_UNLIKELY(!has_remaining_characters(p, 4))) {
+                                return unexpected_end(p);
+                            }
+                            unsigned char c1 = p[1];
+                            if (c1 < 128 || c1 >= 192) {
+                                return make_error(p + 1, ERROR_INVALID_UTF8);
+                            }
+                            unsigned char c2 = p[2];
+                            if (c2 < 128 || c2 >= 192) {
+                                return make_error(p + 2, ERROR_INVALID_UTF8);
+                            }
+                            unsigned char c3 = p[3];
+                            if (c3 < 128 || c3 >= 192) {
+                                return make_error(p + 3, ERROR_INVALID_UTF8);
+                            }
+                            end[0] = c0;
+                            end[1] = c1;
+                            end[2] = c2;
+                            end[3] = c3;
+                            end += 4;
+                            p += 4;
+                        } else {
+                            return make_error(p, ERROR_INVALID_UTF8);
+                        }
+                        break;
+                }
+            }
+        }
+
+        mutable_string_view input;
+        char* const input_end;
+        Allocator allocator;
+
+        type root_type;
+        size_t error_line;
+        size_t error_column;
+        error error_code;
+        int error_arg; // optional argument for the error
+    };
+    /// \endcond
+
+    /**
+     * Parses a string of JSON bytes into a \ref document, given an allocation
+     * strategy instance.  Any kind of string type is valid as long as a
+     * mutable_string_view can be constructed from it.
+     *
+     * Valid allocation strategies are \ref single_allocation,
+     * \ref dynamic_allocation, and \ref bounded_allocation.
+     *
+     * A \ref document is returned whether or not the parse succeeds: success
+     * state is available by calling document::is_valid().
+     */
+    template<typename AllocationStrategy, typename StringType>
+    document parse(const AllocationStrategy& strategy, const StringType& string) {
+        mutable_string_view input(string);
+
+        bool success;
+        auto allocator = strategy.make_allocator(input.length(), &success);
+        if (!success) {
+            return document(input, 1, 1, ERROR_OUT_OF_MEMORY, 0);
+        }
+
+        return parser<typename AllocationStrategy::allocator>(
+            input,
+            std::move(allocator)
+        ).get_document();
+    }
+}
diff --git a/gemmi_gph/gemmi/third_party/tao/LICENSE b/gemmi_gph/gemmi/third_party/tao/LICENSE
new file mode 100644
index 00000000..84bd84ac
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2007-2018 Dr. Colin Hirsch and Daniel Frey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/gemmi_gph/gemmi/third_party/tao/NOTES b/gemmi_gph/gemmi/third_party/tao/NOTES
new file mode 100644
index 00000000..15b8b130
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/NOTES
@@ -0,0 +1,11 @@
+This directory contains files from PEGTL 2.8.3:
+ LICENSE and include/tao/pegtl* except contrib/ and file_mapper_win32.hpp
+with minor modifications (in position.hpp, input_error.hpp, file_input.hpp):
+- changed formatting of error messages,
+- using std::system_error instead of pegtl::input_error.
+- avoiding mmap on Windows (until we upgrade to PEGTL v3),
+  because PEGTL v2 API doesn't support Unicode filenames
+  (and also, including <windows.h> has side-effects)
+
+PEGTL can be updated to v3 only when gemmi drops support for C++11/14.
+https://github.com/project-gemmi/gemmi/issues/212
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl.hpp
new file mode 100644
index 00000000..d20c4e3e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_HPP
+#define TAO_PEGTL_HPP
+
+#include "pegtl/config.hpp"
+#include "pegtl/version.hpp"
+
+#include "pegtl/parse.hpp"
+
+#include "pegtl/ascii.hpp"
+#include "pegtl/rules.hpp"
+#include "pegtl/uint16.hpp"
+#include "pegtl/uint32.hpp"
+#include "pegtl/uint64.hpp"
+#include "pegtl/uint8.hpp"
+#include "pegtl/utf16.hpp"
+#include "pegtl/utf32.hpp"
+#include "pegtl/utf8.hpp"
+
+#include "pegtl/argv_input.hpp"
+#include "pegtl/buffer_input.hpp"
+#include "pegtl/cstream_input.hpp"
+#include "pegtl/istream_input.hpp"
+#include "pegtl/memory_input.hpp"
+#include "pegtl/read_input.hpp"
+#include "pegtl/string_input.hpp"
+
+// this has to be included *after* the above inputs,
+// otherwise the amalgamated header will not work!
+#include "pegtl/file_input.hpp"
+
+#include "pegtl/change_action.hpp"
+#include "pegtl/change_action_and_state.hpp"
+#include "pegtl/change_action_and_states.hpp"
+#include "pegtl/change_control.hpp"
+#include "pegtl/change_state.hpp"
+#include "pegtl/change_states.hpp"
+
+#include "pegtl/disable_action.hpp"
+#include "pegtl/enable_action.hpp"
+
+#include "pegtl/discard_input.hpp"
+#include "pegtl/discard_input_on_failure.hpp"
+#include "pegtl/discard_input_on_success.hpp"
+
+// The following are not included by
+// default because they include <iostream>.
+
+// #include "pegtl/analyze.hpp"
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/analyze_cycles.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/analyze_cycles.hpp
new file mode 100644
index 00000000..6222b04b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/analyze_cycles.hpp
@@ -0,0 +1,135 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_ANALYZE_CYCLES_HPP
+#define TAO_PEGTL_ANALYSIS_ANALYZE_CYCLES_HPP
+
+#include <cassert>
+
+#include <map>
+#include <set>
+#include <stdexcept>
+
+#include <iostream>
+#include <utility>
+
+#include "../config.hpp"
+
+#include "grammar_info.hpp"
+#include "insert_guard.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         class analyze_cycles_impl
+         {
+         protected:
+            explicit analyze_cycles_impl( const bool verbose ) noexcept
+               : m_verbose( verbose ),
+                 m_problems( 0 )
+            {
+            }
+
+            const bool m_verbose;
+            unsigned m_problems;
+            grammar_info m_info;
+            std::set< std::string > m_stack;
+            std::map< std::string, bool > m_cache;
+            std::map< std::string, bool > m_results;
+
+            std::map< std::string, rule_info >::const_iterator find( const std::string& name ) const noexcept
+            {
+               const auto iter = m_info.map.find( name );
+               assert( iter != m_info.map.end() );
+               return iter;
+            }
+
+            bool work( const std::map< std::string, rule_info >::const_iterator& start, const bool accum )
+            {
+               const auto j = m_cache.find( start->first );
+
+               if( j != m_cache.end() ) {
+                  return j->second;
+               }
+               if( const auto g = make_insert_guard( m_stack, start->first ) ) {
+                  switch( start->second.type ) {
+                     case rule_type::any: {
+                        bool a = false;
+                        for( const auto& r : start->second.rules ) {
+                           a = a || work( find( r ), accum || a );
+                        }
+                        return m_cache[ start->first ] = true;
+                     }
+                     case rule_type::opt: {
+                        bool a = false;
+                        for( const auto& r : start->second.rules ) {
+                           a = a || work( find( r ), accum || a );
+                        }
+                        return m_cache[ start->first ] = false;
+                     }
+                     case rule_type::seq: {
+                        bool a = false;
+                        for( const auto& r : start->second.rules ) {
+                           a = a || work( find( r ), accum || a );
+                        }
+                        return m_cache[ start->first ] = a;
+                     }
+                     case rule_type::sor: {
+                        bool a = true;
+                        for( const auto& r : start->second.rules ) {
+                           a = a && work( find( r ), accum );
+                        }
+                        return m_cache[ start->first ] = a;
+                     }
+                  }
+                  throw std::logic_error( "code should be unreachable: invalid rule_type value" );  // NOLINT, LCOV_EXCL_LINE
+               }
+               if( !accum ) {
+                  ++m_problems;
+                  if( m_verbose ) {
+                     std::cout << "problem: cycle without progress detected at rule class " << start->first << std::endl;  // LCOV_EXCL_LINE
+                  }
+               }
+               return m_cache[ start->first ] = accum;
+            }
+         };
+
+         template< typename Grammar >
+         class analyze_cycles
+            : private analyze_cycles_impl
+         {
+         public:
+            explicit analyze_cycles( const bool verbose )
+               : analyze_cycles_impl( verbose )
+            {
+               Grammar::analyze_t::template insert< Grammar >( m_info );
+            }
+
+            std::size_t problems()
+            {
+               for( auto i = m_info.map.begin(); i != m_info.map.end(); ++i ) {
+                  m_results[ i->first ] = work( i, false );
+                  m_cache.clear();
+               }
+               return m_problems;
+            }
+
+            template< typename Rule >
+            bool consumes() const noexcept
+            {
+               const auto i = m_results.find( internal::demangle< Rule >() );
+               assert( i != m_results.end() );
+               return i->second;
+            }
+         };
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/counted.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/counted.hpp
new file mode 100644
index 00000000..6428e186
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/counted.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_COUNTED_HPP
+#define TAO_PEGTL_ANALYSIS_COUNTED_HPP
+
+#include "../config.hpp"
+
+#include <cstddef>
+
+#include "generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         template< rule_type Type, std::size_t Count, typename... Rules >
+         struct counted
+            : generic< ( Count != 0 ) ? Type : rule_type::opt, Rules... >
+         {
+         };
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/generic.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/generic.hpp
new file mode 100644
index 00000000..dc38b9ff
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/generic.hpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_GENERIC_HPP
+#define TAO_PEGTL_ANALYSIS_GENERIC_HPP
+
+#include "../config.hpp"
+
+#include "grammar_info.hpp"
+#include "rule_type.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         template< rule_type Type, typename... Rules >
+         struct generic
+         {
+            template< typename Name >
+            static std::string insert( grammar_info& g )
+            {
+               const auto r = g.insert< Name >( Type );
+               if( r.second ) {
+#ifdef __cpp_fold_expressions
+                  ( r.first->second.rules.push_back( Rules::analyze_t::template insert< Rules >( g ) ), ... );
+#else
+                  using swallow = bool[];
+                  (void)swallow{ ( r.first->second.rules.push_back( Rules::analyze_t::template insert< Rules >( g ) ), true )..., true };
+#endif
+               }
+               return r.first->first;
+            }
+         };
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/grammar_info.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/grammar_info.hpp
new file mode 100644
index 00000000..8c183d98
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/grammar_info.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_GRAMMAR_INFO_HPP
+#define TAO_PEGTL_ANALYSIS_GRAMMAR_INFO_HPP
+
+#include <map>
+#include <string>
+#include <utility>
+
+#include "../config.hpp"
+#include "../internal/demangle.hpp"
+
+#include "rule_info.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         struct grammar_info
+         {
+            using map_t = std::map< std::string, rule_info >;
+            map_t map;
+
+            template< typename Name >
+            std::pair< map_t::iterator, bool > insert( const rule_type type )
+            {
+               return map.insert( map_t::value_type( internal::demangle< Name >(), rule_info( type ) ) );
+            }
+         };
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/insert_guard.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/insert_guard.hpp
new file mode 100644
index 00000000..b56dafff
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/insert_guard.hpp
@@ -0,0 +1,68 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_INSERT_GUARD_HPP
+#define TAO_PEGTL_ANALYSIS_INSERT_GUARD_HPP
+
+#include <utility>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         template< typename C >
+         class insert_guard
+         {
+         public:
+            insert_guard( C& container, const typename C::value_type& value )
+               : m_i( container.insert( value ) ),
+                 m_c( &container )
+            {
+            }
+
+            insert_guard( const insert_guard& ) = delete;
+
+            insert_guard( insert_guard&& other ) noexcept
+               : m_i( other.m_i ),
+                 m_c( other.m_c )
+            {
+               other.m_c = nullptr;
+            }
+
+            ~insert_guard()
+            {
+               if( m_c && m_i.second ) {
+                  m_c->erase( m_i.first );
+               }
+            }
+
+            void operator=( const insert_guard& ) = delete;
+            void operator=( insert_guard&& ) = delete;
+
+            explicit operator bool() const noexcept
+            {
+               return m_i.second;
+            }
+
+         private:
+            const std::pair< typename C::iterator, bool > m_i;
+            C* m_c;
+         };
+
+         template< typename C >
+         insert_guard< C > make_insert_guard( C& container, const typename C::value_type& value )
+         {
+            return insert_guard< C >( container, value );
+         }
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/rule_info.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/rule_info.hpp
new file mode 100644
index 00000000..a222839a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/rule_info.hpp
@@ -0,0 +1,37 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_RULE_INFO_HPP
+#define TAO_PEGTL_ANALYSIS_RULE_INFO_HPP
+
+#include <string>
+#include <vector>
+
+#include "../config.hpp"
+
+#include "rule_type.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         struct rule_info
+         {
+            explicit rule_info( const rule_type in_type ) noexcept
+               : type( in_type )
+            {
+            }
+
+            rule_type type;
+            std::vector< std::string > rules;
+         };
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/rule_type.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/rule_type.hpp
new file mode 100644
index 00000000..a0eff9ad
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analysis/rule_type.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYSIS_RULE_TYPE_HPP
+#define TAO_PEGTL_ANALYSIS_RULE_TYPE_HPP
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace analysis
+      {
+         enum class rule_type : char
+         {
+            any,  // Consumption-on-success is always true; assumes bounded repetition of conjunction of sub-rules.
+            opt,  // Consumption-on-success not necessarily true; assumes bounded repetition of conjunction of sub-rules.
+            seq,  // Consumption-on-success depends on consumption of (non-zero bounded repetition of) conjunction of sub-rules.
+            sor,  // Consumption-on-success depends on consumption of (non-zero bounded repetition of) disjunction of sub-rules.
+
+            // Compatibility, remove with 3.0.0
+            ANY = any,
+            OPT = opt,
+            SEQ = seq,
+            SOR = sor
+         };
+
+      }  // namespace analysis
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/analyze.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/analyze.hpp
new file mode 100644
index 00000000..bf50dc5c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/analyze.hpp
@@ -0,0 +1,25 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ANALYZE_HPP
+#define TAO_PEGTL_ANALYZE_HPP
+
+#include "config.hpp"
+
+#include "analysis/analyze_cycles.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Rule >
+      std::size_t analyze( const bool verbose = true )
+      {
+         return analysis::analyze_cycles< Rule >( verbose ).problems();
+      }
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/apply_mode.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/apply_mode.hpp
new file mode 100644
index 00000000..92c13350
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/apply_mode.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_APPLY_MODE_HPP
+#define TAO_PEGTL_APPLY_MODE_HPP
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      enum class apply_mode : bool
+      {
+         action = true,
+         nothing = false,
+
+         // Compatibility, remove with 3.0.0
+         ACTION = action,
+         NOTHING = nothing
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/argv_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/argv_input.hpp
new file mode 100644
index 00000000..75744a32
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/argv_input.hpp
@@ -0,0 +1,57 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ARGV_INPUT_HPP
+#define TAO_PEGTL_ARGV_INPUT_HPP
+
+#include <cstddef>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "memory_input.hpp"
+#include "tracking_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline std::string make_argv_source( const std::size_t argn )
+         {
+            std::ostringstream os;
+            os << "argv[" << argn << ']';
+            return os.str();
+         }
+
+      }  // namespace internal
+
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
+      struct argv_input
+         : public memory_input< P, Eol >
+      {
+         template< typename T >
+         argv_input( char** argv, const std::size_t argn, T&& in_source )
+            : memory_input< P, Eol >( static_cast< const char* >( argv[ argn ] ), std::forward< T >( in_source ) )
+         {
+         }
+
+         argv_input( char** argv, const std::size_t argn )
+            : argv_input( argv, argn, internal::make_argv_source( argn ) )
+         {
+         }
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      argv_input( Ts&&... )->argv_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/ascii.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/ascii.hpp
new file mode 100644
index 00000000..51cb0e40
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/ascii.hpp
@@ -0,0 +1,71 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ASCII_HPP
+#define TAO_PEGTL_ASCII_HPP
+
+#include "config.hpp"
+#include "eol.hpp"
+
+#include "internal/always_false.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      inline namespace ascii
+      {
+         // clang-format off
+         struct alnum : internal::alnum {};
+         struct alpha : internal::alpha {};
+         struct any : internal::any< internal::peek_char > {};
+         struct blank : internal::one< internal::result_on_found::success, internal::peek_char, ' ', '\t' > {};
+         struct digit : internal::range< internal::result_on_found::success, internal::peek_char, '0', '9' > {};
+         struct ellipsis : internal::string< '.', '.', '.' > {};
+         struct eolf : internal::eolf {};
+         template< char... Cs > struct forty_two : internal::rep< 42, internal::one< internal::result_on_found::success, internal::peek_char, Cs... > > {};
+         struct identifier_first : internal::identifier_first {};
+         struct identifier_other : internal::identifier_other {};
+         struct identifier : internal::identifier {};
+         template< char... Cs > struct istring : internal::istring< Cs... > {};
+         template< char... Cs > struct keyword : internal::seq< internal::string< Cs... >, internal::not_at< internal::identifier_other > > {};
+         struct lower : internal::range< internal::result_on_found::success, internal::peek_char, 'a', 'z' > {};
+         template< char... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_char, Cs... > {};
+         template< char Lo, char Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_char, Lo, Hi > {};
+         struct nul : internal::one< internal::result_on_found::success, internal::peek_char, char( 0 ) > {};
+         template< char... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_char, Cs... > {};
+         struct print : internal::range< internal::result_on_found::success, internal::peek_char, char( 32 ), char( 126 ) > {};
+         template< char Lo, char Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_char, Lo, Hi > {};
+         template< char... Cs > struct ranges : internal::ranges< internal::peek_char, Cs... > {};
+         struct seven : internal::range< internal::result_on_found::success, internal::peek_char, char( 0 ), char( 127 ) > {};
+         struct shebang : internal::if_must< false, internal::string< '#', '!' >, internal::until< internal::eolf > > {};
+         struct space : internal::one< internal::result_on_found::success, internal::peek_char, ' ', '\n', '\r', '\t', '\v', '\f' > {};
+         template< char... Cs > struct string : internal::string< Cs... > {};
+         template< char C > struct three : internal::string< C, C, C > {};
+         template< char C > struct two : internal::string< C, C > {};
+         struct upper : internal::range< internal::result_on_found::success, internal::peek_char, 'A', 'Z' > {};
+         struct xdigit : internal::ranges< internal::peek_char, '0', '9', 'a', 'f', 'A', 'F' > {};
+         // clang-format on
+
+         template<>
+         struct keyword<>
+         {
+            template< typename Input >
+            static bool match( Input& /*unused*/ ) noexcept
+            {
+               static_assert( internal::always_false< Input >::value, "empty keywords not allowed" );
+               return false;
+            }
+         };
+
+      }  // namespace ascii
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#include "internal/pegtl_string.hpp"
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/buffer_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/buffer_input.hpp
new file mode 100644
index 00000000..f43513ab
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/buffer_input.hpp
@@ -0,0 +1,222 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_BUFFER_INPUT_HPP
+#define TAO_PEGTL_BUFFER_INPUT_HPP
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "memory_input.hpp"
+#include "position.hpp"
+#include "tracking_mode.hpp"
+
+#include "internal/action_input.hpp"
+#include "internal/bump.hpp"
+#include "internal/iterator.hpp"
+#include "internal/marker.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Reader, typename Eol = eol::lf_crlf, typename Source = std::string, std::size_t Chunk = 64 >
+      class buffer_input
+      {
+      public:
+         using reader_t = Reader;
+
+         using eol_t = Eol;
+         using source_t = Source;
+
+         using iterator_t = internal::iterator;
+
+         using action_t = internal::action_input< buffer_input >;
+
+         static constexpr std::size_t chunk_size = Chunk;
+         static constexpr tracking_mode tracking_mode_v = tracking_mode::eager;
+
+         template< typename T, typename... As >
+         buffer_input( T&& in_source, const std::size_t maximum, As&&... as )
+            : m_reader( std::forward< As >( as )... ),
+              m_maximum( maximum + Chunk ),
+              m_buffer( new char[ maximum + Chunk ] ),
+              m_current( m_buffer.get() ),
+              m_end( m_buffer.get() ),
+              m_source( std::forward< T >( in_source ) )
+         {
+            static_assert( Chunk != 0, "zero chunk size not implemented" );
+            assert( m_maximum > maximum );  // Catches overflow; change to >= when zero chunk size is implemented.
+         }
+
+         buffer_input( const buffer_input& ) = delete;
+         buffer_input( buffer_input&& ) = delete;
+
+         ~buffer_input() = default;
+
+         void operator=( const buffer_input& ) = delete;
+         void operator=( buffer_input&& ) = delete;
+
+         bool empty()
+         {
+            require( 1 );
+            return m_current.data == m_end;
+         }
+
+         std::size_t size( const std::size_t amount )
+         {
+            require( amount );
+            return buffer_occupied();
+         }
+
+         const char* current() const noexcept
+         {
+            return m_current.data;
+         }
+
+         const char* end( const std::size_t amount )
+         {
+            require( amount );
+            return m_end;
+         }
+
+         std::size_t byte() const noexcept
+         {
+            return m_current.byte;
+         }
+
+         std::size_t line() const noexcept
+         {
+            return m_current.line;
+         }
+
+         std::size_t byte_in_line() const noexcept
+         {
+            return m_current.byte_in_line;
+         }
+
+         const Source& source() const noexcept
+         {
+            return m_source;
+         }
+
+         char peek_char( const std::size_t offset = 0 ) const noexcept
+         {
+            return m_current.data[ offset ];
+         }
+
+         std::uint8_t peek_uint8( const std::size_t offset = 0 ) const noexcept
+         {
+            return static_cast< std::uint8_t >( peek_char( offset ) );
+         }
+
+         // Compatibility, remove with 3.0.0
+         std::uint8_t peek_byte( const std::size_t offset = 0 ) const noexcept
+         {
+            return static_cast< std::uint8_t >( peek_char( offset ) );
+         }
+
+         void bump( const std::size_t in_count = 1 ) noexcept
+         {
+            internal::bump( m_current, in_count, Eol::ch );
+         }
+
+         void bump_in_this_line( const std::size_t in_count = 1 ) noexcept
+         {
+            internal::bump_in_this_line( m_current, in_count );
+         }
+
+         void bump_to_next_line( const std::size_t in_count = 1 ) noexcept
+         {
+            internal::bump_to_next_line( m_current, in_count );
+         }
+
+         void discard() noexcept
+         {
+            if( m_current.data > m_buffer.get() + Chunk ) {
+               const auto s = m_end - m_current.data;
+               std::memmove( m_buffer.get(), m_current.data, s );
+               m_current.data = m_buffer.get();
+               m_end = m_buffer.get() + s;
+            }
+         }
+
+         void require( const std::size_t amount )
+         {
+            if( m_current.data + amount <= m_end ) {
+               return;
+            }
+            if( m_current.data + amount > m_buffer.get() + m_maximum ) {
+               throw std::overflow_error( "require beyond end of buffer" );
+            }
+            if( const auto r = m_reader( m_end, ( std::min )( buffer_free_after_end(), ( std::max )( amount - buffer_occupied(), Chunk ) ) ) ) {
+               m_end += r;
+            }
+         }
+
+         template< rewind_mode M >
+         internal::marker< iterator_t, M > mark() noexcept
+         {
+            return internal::marker< iterator_t, M >( m_current );
+         }
+
+         TAO_PEGTL_NAMESPACE::position position( const iterator_t& it ) const
+         {
+            return TAO_PEGTL_NAMESPACE::position( it, m_source );
+         }
+
+         TAO_PEGTL_NAMESPACE::position position() const
+         {
+            return position( m_current );
+         }
+
+         const iterator_t& iterator() const noexcept
+         {
+            return m_current;
+         }
+
+         std::size_t buffer_capacity() const noexcept
+         {
+            return m_maximum;
+         }
+
+         std::size_t buffer_occupied() const noexcept
+         {
+            assert( m_end >= m_current.data );
+            return std::size_t( m_end - m_current.data );
+         }
+
+         std::size_t buffer_free_before_current() const noexcept
+         {
+            assert( m_current.data >= m_buffer.get() );
+            return std::size_t( m_current.data - m_buffer.get() );
+         }
+
+         std::size_t buffer_free_after_end() const noexcept
+         {
+            assert( m_buffer.get() + m_maximum >= m_end );
+            return std::size_t( m_buffer.get() + m_maximum - m_end );
+         }
+
+      private:
+         Reader m_reader;
+         std::size_t m_maximum;
+         std::unique_ptr< char[] > m_buffer;  // NOLINT
+         iterator_t m_current;
+         char* m_end;
+         const Source m_source;
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/change_action.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/change_action.hpp
new file mode 100644
index 00000000..1766e933
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/change_action.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CHANGE_ACTION_HPP
+#define TAO_PEGTL_CHANGE_ACTION_HPP
+
+#include <type_traits>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< template< typename... > class NewAction >
+      struct change_action
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            static_assert( !std::is_same< Action< void >, NewAction< void > >::value, "old and new action class templates are identical" );
+            return Control< Rule >::template match< A, M, NewAction, Control >( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/change_action_and_state.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/change_action_and_state.hpp
new file mode 100644
index 00000000..f76eb314
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/change_action_and_state.hpp
@@ -0,0 +1,73 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CHANGE_ACTION_AND_STATE_HPP
+#define TAO_PEGTL_CHANGE_ACTION_AND_STATE_HPP
+
+#include <type_traits>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< template< typename... > class NewAction, typename NewState >
+      struct change_action_and_state
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< ( A == apply_mode::action ), bool >::type
+         {
+            static_assert( !std::is_same< Action< void >, NewAction< void > >::value, "old and new action class templates are identical" );
+            NewState s( static_cast< const Input& >( in ), st... );
+            if( Control< Rule >::template match< A, M, NewAction, Control >( in, s ) ) {
+               Action< Rule >::success( static_cast< const Input& >( in ), s, st... );
+               return true;
+            }
+            return false;
+         }
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States,
+                   int = 1 >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< ( A == apply_mode::nothing ), bool >::type
+         {
+            static_assert( !std::is_same< Action< void >, NewAction< void > >::value, "old and new action class templates are identical" );
+            NewState s( static_cast< const Input& >( in ), st... );
+            return Control< Rule >::template match< A, M, NewAction, Control >( in, s );
+         }
+
+         template< typename Input,
+                   typename... States >
+         static void success( const Input& in, NewState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
+         {
+            s.success( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/change_action_and_states.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/change_action_and_states.hpp
new file mode 100644
index 00000000..42d51e98
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/change_action_and_states.hpp
@@ -0,0 +1,83 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CHANGE_ACTION_AND_STATES_HPP
+#define TAO_PEGTL_CHANGE_ACTION_AND_STATES_HPP
+
+#include <tuple>
+#include <type_traits>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+#include "internal/integer_sequence.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< template< typename... > class NewAction, typename... NewStates >
+      struct change_action_and_states
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   std::size_t... Ns,
+                   typename Input,
+                   typename... States >
+         static bool match( TAO_PEGTL_NAMESPACE::internal::index_sequence< Ns... >, Input& in, States&&... st )
+         {
+            auto t = std::tie( st... );
+            if( Control< Rule >::template match< A, M, NewAction, Control >( in, std::get< Ns >( t )... ) ) {
+               Action< Rule >::success( static_cast< const Input& >( in ), st... );
+               return true;
+            }
+            return false;
+         }
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< ( A == apply_mode::action ), bool >::type
+         {
+            static_assert( !std::is_same< Action< void >, NewAction< void > >::value, "old and new action class templates are identical" );
+            return match< Rule, A, M, Action, Control >( TAO_PEGTL_NAMESPACE::internal::index_sequence_for< NewStates... >(), in, NewStates()..., st... );
+         }
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States,
+                   int = 1 >
+         static auto match( Input& in, States&&... /*unused*/ )
+            -> typename std::enable_if< ( A == apply_mode::nothing ), bool >::type
+         {
+            static_assert( !std::is_same< Action< void >, NewAction< void > >::value, "old and new action class templates are identical" );
+            return Control< Rule >::template match< A, M, NewAction, Control >( in, NewStates()... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/change_control.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/change_control.hpp
new file mode 100644
index 00000000..ba9251ff
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/change_control.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CHANGE_CONTROL_HPP
+#define TAO_PEGTL_CHANGE_CONTROL_HPP
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< template< typename... > class NewControl >
+      struct change_control
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, NewControl >( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/change_state.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/change_state.hpp
new file mode 100644
index 00000000..3f8e4d50
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/change_state.hpp
@@ -0,0 +1,72 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CHANGE_STATE_HPP
+#define TAO_PEGTL_CHANGE_STATE_HPP
+
+#include <type_traits>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename NewState >
+      struct change_state
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< ( A == apply_mode::action ), bool >::type
+         {
+            NewState s( static_cast< const Input& >( in ), st... );
+            if( TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, s ) ) {
+               Action< Rule >::success( static_cast< const Input& >( in ), s, st... );
+               return true;
+            }
+            return false;
+         }
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States,
+                   int = 1 >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< ( A == apply_mode::nothing ), bool >::type
+         {
+            NewState s( static_cast< const Input& >( in ), st... );
+            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, s );
+         }
+
+         template< typename Input,
+                   typename... States >
+         static void success( const Input& in, NewState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
+         {
+            s.success( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/change_states.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/change_states.hpp
new file mode 100644
index 00000000..151f410c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/change_states.hpp
@@ -0,0 +1,81 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CHANGE_STATES_HPP
+#define TAO_PEGTL_CHANGE_STATES_HPP
+
+#include <tuple>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+#include "internal/integer_sequence.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename... NewStates >
+      struct change_states
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   std::size_t... Ns,
+                   typename Input,
+                   typename... States >
+         static bool match( TAO_PEGTL_NAMESPACE::internal::index_sequence< Ns... >, Input& in, States&&... st )
+         {
+            auto t = std::tie( st... );
+            if( TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, std::get< Ns >( t )... ) ) {
+               Action< Rule >::success( static_cast< const Input& >( in ), st... );
+               return true;
+            }
+            return false;
+         }
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< ( A == apply_mode::action ), bool >::type
+         {
+            return match< Rule, A, M, Action, Control >( TAO_PEGTL_NAMESPACE::internal::index_sequence_for< NewStates... >(), in, NewStates()..., st... );
+         }
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States,
+                   int = 1 >
+         static auto match( Input& in, States&&... /*unused*/ )
+            -> typename std::enable_if< ( A == apply_mode::nothing ), bool >::type
+         {
+            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, NewStates()... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/config.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/config.hpp
new file mode 100644
index 00000000..4e47abaa
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/config.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CONFIG_HPP
+#define TAO_PEGTL_CONFIG_HPP
+
+// Compatibility, remove with 3.0.0
+#ifdef TAOCPP_PEGTL_NAMESPACE
+#define TAO_PEGTL_NAMESPACE TAOCPP_PEGTL_NAMESPACE
+#endif
+
+#ifndef TAO_PEGTL_NAMESPACE
+#define TAO_PEGTL_NAMESPACE pegtl
+#endif
+
+// Enable some improvements to the readability of
+// demangled type names under some circumstances.
+// #define TAO_PEGTL_PRETTY_DEMANGLE
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/cstream_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/cstream_input.hpp
new file mode 100644
index 00000000..d14e828e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/cstream_input.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CSTREAM_INPUT_HPP
+#define TAO_PEGTL_CSTREAM_INPUT_HPP
+
+#include <cstdio>
+
+#include "buffer_input.hpp"
+#include "config.hpp"
+#include "eol.hpp"
+
+#include "internal/cstream_reader.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Eol = eol::lf_crlf, std::size_t Chunk = 64 >
+      struct cstream_input
+         : buffer_input< internal::cstream_reader, Eol, std::string, Chunk >
+      {
+         template< typename T >
+         cstream_input( std::FILE* in_stream, const std::size_t in_maximum, T&& in_source )
+            : buffer_input< internal::cstream_reader, Eol, std::string, Chunk >( std::forward< T >( in_source ), in_maximum, in_stream )
+         {
+         }
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      cstream_input( Ts&&... )->cstream_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/disable_action.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/disable_action.hpp
new file mode 100644
index 00000000..de51f0bb
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/disable_action.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_DISABLE_ACTION_HPP
+#define TAO_PEGTL_DISABLE_ACTION_HPP
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct disable_action
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            return TAO_PEGTL_NAMESPACE::match< Rule, apply_mode::nothing, M, Action, Control >( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input.hpp
new file mode 100644
index 00000000..e2e226ff
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_DISCARD_INPUT_HPP
+#define TAO_PEGTL_DISCARD_INPUT_HPP
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct discard_input
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            const bool result = TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
+            in.discard();
+            return result;
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input_on_failure.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input_on_failure.hpp
new file mode 100644
index 00000000..1be1bdbc
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input_on_failure.hpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_DISCARD_INPUT_ON_FAILURE_HPP
+#define TAO_PEGTL_DISCARD_INPUT_ON_FAILURE_HPP
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct discard_input_on_failure
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            const bool result = TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
+            if( !result ) {
+               in.discard();
+            }
+            return result;
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input_on_success.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input_on_success.hpp
new file mode 100644
index 00000000..56cc1cbc
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/discard_input_on_success.hpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_DISCARD_INPUT_ON_SUCCESS_HPP
+#define TAO_PEGTL_DISCARD_INPUT_ON_SUCCESS_HPP
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct discard_input_on_success
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            const bool result = TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
+            if( result ) {
+               in.discard();
+            }
+            return result;
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/enable_action.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/enable_action.hpp
new file mode 100644
index 00000000..12447c3e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/enable_action.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ENABLE_ACTION_HPP
+#define TAO_PEGTL_ENABLE_ACTION_HPP
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "nothing.hpp"
+#include "rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct enable_action
+         : maybe_nothing
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static bool match( Input& in, States&&... st )
+         {
+            return TAO_PEGTL_NAMESPACE::match< Rule, apply_mode::action, M, Action, Control >( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/eol.hpp
new file mode 100644
index 00000000..e8150645
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/eol.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_EOL_HPP
+#define TAO_PEGTL_EOL_HPP
+
+#include "config.hpp"
+
+#include "internal/eol.hpp"
+
+#include "internal/cr_crlf_eol.hpp"
+#include "internal/cr_eol.hpp"
+#include "internal/crlf_eol.hpp"
+#include "internal/lf_crlf_eol.hpp"
+#include "internal/lf_eol.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      inline namespace ascii
+      {
+         // this is both a rule and a pseudo-namespace for eol::cr, ...
+         struct eol : internal::eol
+         {
+            // clang-format off
+            struct cr : internal::cr_eol {};
+            struct cr_crlf : internal::cr_crlf_eol {};
+            struct crlf : internal::crlf_eol {};
+            struct lf : internal::lf_eol {};
+            struct lf_crlf : internal::lf_crlf_eol {};
+            // clang-format on
+         };
+
+      }  // namespace ascii
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/eol_pair.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/eol_pair.hpp
new file mode 100644
index 00000000..5e3072bc
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/eol_pair.hpp
@@ -0,0 +1,22 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_EOL_PAIR_HPP
+#define TAO_PEGTL_EOL_PAIR_HPP
+
+#include <cstddef>
+#include <utility>
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      using eol_pair = std::pair< bool, std::size_t >;
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/file_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/file_input.hpp
new file mode 100644
index 00000000..248e7039
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/file_input.hpp
@@ -0,0 +1,50 @@
+// Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_FILE_INPUT_HPP
+#define TAO_PEGTL_FILE_INPUT_HPP
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "tracking_mode.hpp"
+
+#if defined( __unix__ ) || ( defined( __APPLE__ ) && defined( __MACH__ ) )
+#include <unistd.h>  // Required for _POSIX_MAPPED_FILES
+#endif
+
+#if defined( _POSIX_MAPPED_FILES )
+#include "mmap_input.hpp"
+#else
+#include "read_input.hpp"
+#endif
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+#if defined( _POSIX_MAPPED_FILES )
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
+      struct file_input
+         : mmap_input< P, Eol >
+      {
+         using mmap_input< P, Eol >::mmap_input;
+      };
+#else
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
+      struct file_input
+         : read_input< P, Eol >
+      {
+         using read_input< P, Eol >::read_input;
+      };
+#endif
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      explicit file_input( Ts&&... )->file_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/input_error.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/input_error.hpp
new file mode 100644
index 00000000..c0d1a076
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/input_error.hpp
@@ -0,0 +1,57 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INPUT_ERROR_HPP
+#define TAO_PEGTL_INPUT_ERROR_HPP
+
+#include <cerrno>
+#include <sstream>
+#include <stdexcept>
+#include <system_error>
+
+#include "config.hpp"
+
+// In PEGTL 3 input_error was changed to std::system_error and
+// std::filesystem::filesystem_error (the latter is derived from the former).
+// Here we half-backported it - input_error is replaced with system_error.
+#if 0
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct input_error
+         : std::runtime_error
+      {
+         input_error( const std::string& message, const int in_errorno )
+            : std::runtime_error( message ),
+              errorno( in_errorno )
+         {
+         }
+
+         int errorno;
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+#endif
+
+#define TAO_PEGTL_INTERNAL_UNWRAP( ... ) __VA_ARGS__
+
+#define TAO_PEGTL_THROW_INPUT_ERROR( MESSAGE )                                          \
+   do {                                                                                 \
+      const int errorno = errno;                                                        \
+      std::ostringstream oss;                                                           \
+      oss << TAO_PEGTL_INTERNAL_UNWRAP( MESSAGE ); \
+      throw std::system_error( errorno, std::system_category(), oss.str() );            \
+   } while( false )
+
+#define TAO_PEGTL_THROW_INPUT_WIN32_ERROR( MESSAGE )                                             \
+   do {                                                                                          \
+      const int errorno = GetLastError();                                                        \
+      std::ostringstream oss;                                                                    \
+      oss << TAO_PEGTL_INTERNAL_UNWRAP( MESSAGE ); \
+      throw std::system_error( errorno, std::system_category(), oss.str() );            \
+   } while( false )
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/action.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/action.hpp
new file mode 100644
index 00000000..ac693625
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/action.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ACTION_HPP
+#define TAO_PEGTL_INTERNAL_ACTION_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< template< typename... > class Action, typename... Rules >
+         struct action
+            : action< Action, seq< Rules... > >
+         {
+         };
+
+         template< template< typename... > class Action, typename Rule >
+         struct action< Action, Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< A, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< template< typename... > class Action, typename... Rules >
+         struct skip_control< action< Action, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/action_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/action_input.hpp
new file mode 100644
index 00000000..023bae96
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/action_input.hpp
@@ -0,0 +1,120 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ACTION_INPUT_HPP
+#define TAO_PEGTL_INTERNAL_ACTION_INPUT_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "iterator.hpp"
+
+#include "../config.hpp"
+#include "../position.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline const char* begin_c_ptr( const char* p ) noexcept
+         {
+            return p;
+         }
+
+         inline const char* begin_c_ptr( const iterator& it ) noexcept
+         {
+            return it.data;
+         }
+
+         template< typename Input >
+         class action_input
+         {
+         public:
+            using input_t = Input;
+            using iterator_t = typename Input::iterator_t;
+
+            action_input( const iterator_t& in_begin, const Input& in_input ) noexcept
+               : m_begin( in_begin ),
+                 m_input( in_input )
+            {
+            }
+
+            action_input( const action_input& ) = delete;
+            action_input( action_input&& ) = delete;
+
+            ~action_input() = default;
+
+            action_input& operator=( const action_input& ) = delete;
+            action_input& operator=( action_input&& ) = delete;
+
+            const iterator_t& iterator() const noexcept
+            {
+               return m_begin;
+            }
+
+            const Input& input() const noexcept
+            {
+               return m_input;
+            }
+
+            const char* begin() const noexcept
+            {
+               return begin_c_ptr( iterator() );
+            }
+
+            const char* end() const noexcept
+            {
+               return input().current();
+            }
+
+            bool empty() const noexcept
+            {
+               return begin() == end();
+            }
+
+            std::size_t size() const noexcept
+            {
+               return std::size_t( end() - begin() );
+            }
+
+            std::string string() const
+            {
+               return std::string( begin(), end() );
+            }
+
+            char peek_char( const std::size_t offset = 0 ) const noexcept
+            {
+               return begin()[ offset ];
+            }
+
+            std::uint8_t peek_uint8( const std::size_t offset = 0 ) const noexcept
+            {
+               return static_cast< std::uint8_t >( peek_char( offset ) );
+            }
+
+            // Compatibility, remove with 3.0.0
+            std::uint8_t peek_byte( const std::size_t offset = 0 ) const noexcept
+            {
+               return static_cast< std::uint8_t >( peek_char( offset ) );
+            }
+
+            TAO_PEGTL_NAMESPACE::position position() const
+            {
+               return input().position( iterator() );  // NOTE: Not efficient with lazy inputs.
+            }
+
+         protected:
+            const iterator_t m_begin;
+            const Input& m_input;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/alnum.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/alnum.hpp
new file mode 100644
index 00000000..de96d3a6
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/alnum.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ALNUM_HPP
+#define TAO_PEGTL_INTERNAL_ALNUM_HPP
+
+#include "../config.hpp"
+
+#include "peek_char.hpp"
+#include "ranges.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         using alnum = ranges< peek_char, 'a', 'z', 'A', 'Z', '0', '9' >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/alpha.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/alpha.hpp
new file mode 100644
index 00000000..aeeebfde
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/alpha.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ALPHA_HPP
+#define TAO_PEGTL_INTERNAL_ALPHA_HPP
+
+#include "../config.hpp"
+
+#include "peek_char.hpp"
+#include "ranges.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         using alpha = ranges< peek_char, 'a', 'z', 'A', 'Z' >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/always_false.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/always_false.hpp
new file mode 100644
index 00000000..8683cad4
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/always_false.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ALWAYS_FALSE_HPP
+#define TAO_PEGTL_INTERNAL_ALWAYS_FALSE_HPP
+
+#include "../config.hpp"
+
+#include <type_traits>
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... >
+         struct always_false
+            : std::false_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/any.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/any.hpp
new file mode 100644
index 00000000..b1aee22d
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/any.hpp
@@ -0,0 +1,66 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ANY_HPP
+#define TAO_PEGTL_INTERNAL_ANY_HPP
+
+#include "../config.hpp"
+
+#include "peek_char.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Peek >
+         struct any;
+
+         template<>
+         struct any< peek_char >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( in.empty() ) )
+            {
+               if( !in.empty() ) {
+                  in.bump();
+                  return true;
+               }
+               return false;
+            }
+         };
+
+         template< typename Peek >
+         struct any
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Peek::peek( in ) ) )
+            {
+               if( const auto t = Peek::peek( in ) ) {
+                  in.bump( t.size );
+                  return true;
+               }
+               return false;
+            }
+         };
+
+         template< typename Peek >
+         struct skip_control< any< Peek > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply.hpp
new file mode 100644
index 00000000..a2d35d84
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply.hpp
@@ -0,0 +1,94 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_APPLY_HPP
+#define TAO_PEGTL_INTERNAL_APPLY_HPP
+
+#include "../config.hpp"
+
+#include "apply_single.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/counted.hpp"
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< apply_mode A, typename... Actions >
+         struct apply_impl;
+
+         template<>
+         struct apply_impl< apply_mode::action >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& /*unused*/, States&&... /*unused*/ )
+            {
+               return true;
+            }
+         };
+
+         template< typename... Actions >
+         struct apply_impl< apply_mode::action, Actions... >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               using action_t = typename Input::action_t;
+               const action_t i2( in.iterator(), in );  // No data -- range is from begin to begin.
+#ifdef __cpp_fold_expressions
+               return ( apply_single< Actions >::match( i2, st... ) && ... );
+#else
+               bool result = true;
+               using swallow = bool[];
+               (void)swallow{ result = result && apply_single< Actions >::match( i2, st... )... };
+               return result;
+#endif
+            }
+         };
+
+         template< typename... Actions >
+         struct apply_impl< apply_mode::nothing, Actions... >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& /*unused*/, States&&... /*unused*/ )
+            {
+               return true;
+            }
+         };
+
+         template< typename... Actions >
+         struct apply
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::any, 0 >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return apply_impl< A, Actions... >::match( in, st... );
+            }
+         };
+
+         template< typename... Actions >
+         struct skip_control< apply< Actions... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply0.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply0.hpp
new file mode 100644
index 00000000..192c9c5a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply0.hpp
@@ -0,0 +1,92 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_APPLY0_HPP
+#define TAO_PEGTL_INTERNAL_APPLY0_HPP
+
+#include "../config.hpp"
+
+#include "apply0_single.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/counted.hpp"
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< apply_mode A, typename... Actions >
+         struct apply0_impl;
+
+         template<>
+         struct apply0_impl< apply_mode::action >
+         {
+            template< typename... States >
+            static bool match( States&&... /*unused*/ ) noexcept
+            {
+               return true;
+            }
+         };
+
+         template< typename... Actions >
+         struct apply0_impl< apply_mode::action, Actions... >
+         {
+            template< typename... States >
+            static bool match( States&&... st )
+            {
+#ifdef __cpp_fold_expressions
+               return ( apply0_single< Actions >::match( st... ) && ... );
+#else
+               bool result = true;
+               using swallow = bool[];
+               (void)swallow{ result = result && apply0_single< Actions >::match( st... )... };
+               return result;
+#endif
+            }
+         };
+
+         template< typename... Actions >
+         struct apply0_impl< apply_mode::nothing, Actions... >
+         {
+            template< typename... States >
+            static bool match( States&&... /*unused*/ ) noexcept
+            {
+               return true;
+            }
+         };
+
+         template< typename... Actions >
+         struct apply0
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::any, 0 >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& /*unused*/, States&&... st )
+            {
+               return apply0_impl< A, Actions... >::match( st... );
+            }
+         };
+
+         template< typename... Actions >
+         struct skip_control< apply0< Actions... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply0_single.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply0_single.hpp
new file mode 100644
index 00000000..7fe8cacc
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply0_single.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_APPLY0_SINGLE_HPP
+#define TAO_PEGTL_INTERNAL_APPLY0_SINGLE_HPP
+
+#include "../config.hpp"
+
+#include <type_traits>
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Action >
+         struct apply0_single
+         {
+            template< typename... States >
+            static auto match( States&&... st )
+               -> typename std::enable_if< std::is_same< decltype( Action::apply0( st... ) ), void >::value, bool >::type
+            {
+               Action::apply0( st... );
+               return true;
+            }
+
+            template< typename... States >
+            static auto match( States&&... st )
+               -> typename std::enable_if< std::is_same< decltype( Action::apply0( st... ) ), bool >::value, bool >::type
+            {
+               return Action::apply0( st... );
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply_single.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply_single.hpp
new file mode 100644
index 00000000..5300cbc1
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/apply_single.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_APPLY_SINGLE_HPP
+#define TAO_PEGTL_INTERNAL_APPLY_SINGLE_HPP
+
+#include "../config.hpp"
+
+#include <type_traits>
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Action >
+         struct apply_single
+         {
+            template< typename Input, typename... States >
+            static auto match( const Input& i2, States&&... st )
+               -> typename std::enable_if< std::is_same< decltype( Action::apply( i2, st... ) ), void >::value, bool >::type
+            {
+               Action::apply( i2, st... );
+               return true;
+            }
+
+            template< typename Input, typename... States >
+            static auto match( const Input& i2, States&&... st )
+               -> typename std::enable_if< std::is_same< decltype( Action::apply( i2, st... ) ), bool >::value, bool >::type
+            {
+               return Action::apply( i2, st... );
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/at.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/at.hpp
new file mode 100644
index 00000000..688bda7c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/at.hpp
@@ -0,0 +1,67 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_AT_HPP
+#define TAO_PEGTL_INTERNAL_AT_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct at
+            : at< seq< Rules... > >
+         {
+         };
+
+         template<>
+         struct at<>
+            : trivial< true >
+         {
+         };
+
+         template< typename Rule >
+         struct at< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt, Rule >;
+
+            template< apply_mode,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               const auto m = in.template mark< rewind_mode::required >();
+               return Control< Rule >::template match< apply_mode::nothing, rewind_mode::active, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< at< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bof.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bof.hpp
new file mode 100644
index 00000000..2f7327e1
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bof.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_BOF_HPP
+#define TAO_PEGTL_INTERNAL_BOF_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct bof
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept
+            {
+               return in.byte() == 0;
+            }
+         };
+
+         template<>
+         struct skip_control< bof > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bol.hpp
new file mode 100644
index 00000000..0eb3ef71
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bol.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_BOL_HPP
+#define TAO_PEGTL_INTERNAL_BOL_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct bol
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept
+            {
+               return in.byte_in_line() == 0;
+            }
+         };
+
+         template<>
+         struct skip_control< bol > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bump.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bump.hpp
new file mode 100644
index 00000000..bbaeb0e2
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bump.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_BUMP_HPP
+#define TAO_PEGTL_INTERNAL_BUMP_HPP
+
+#include "../config.hpp"
+
+#include "iterator.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline void bump( iterator& iter, const std::size_t count, const int ch ) noexcept
+         {
+            for( std::size_t i = 0; i < count; ++i ) {
+               if( iter.data[ i ] == ch ) {
+                  ++iter.line;
+                  iter.byte_in_line = 0;
+               }
+               else {
+                  ++iter.byte_in_line;
+               }
+            }
+            iter.byte += count;
+            iter.data += count;
+         }
+
+         inline void bump_in_this_line( iterator& iter, const std::size_t count ) noexcept
+         {
+            iter.data += count;
+            iter.byte += count;
+            iter.byte_in_line += count;
+         }
+
+         inline void bump_to_next_line( iterator& iter, const std::size_t count ) noexcept
+         {
+            ++iter.line;
+            iter.byte += count;
+            iter.byte_in_line = 0;
+            iter.data += count;
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bump_help.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bump_help.hpp
new file mode 100644
index 00000000..fce2fadd
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bump_help.hpp
@@ -0,0 +1,63 @@
+// Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_BUMP_HELP_HPP
+#define TAO_PEGTL_INTERNAL_BUMP_HELP_HPP
+
+#include <cstddef>
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "result_on_found.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< bool >
+         struct bump_impl;
+
+         template<>
+         struct bump_impl< true >
+         {
+            template< typename Input >
+            static void bump( Input& in, const std::size_t count ) noexcept
+            {
+               in.bump( count );
+            }
+         };
+
+         template<>
+         struct bump_impl< false >
+         {
+            template< typename Input >
+            static void bump( Input& in, const std::size_t count ) noexcept
+            {
+               in.bump_in_this_line( count );
+            }
+         };
+
+         template< bool... >
+         struct bool_list
+         {
+         };
+
+         template< bool... Bs >
+         using bool_and = std::is_same< bool_list< Bs..., true >, bool_list< true, Bs... > >;
+
+         template< result_on_found R, typename Input, typename Char, Char... Cs >
+         void bump_help( Input& in, const std::size_t count ) noexcept
+         {
+            bump_impl< bool_and< ( Cs != Input::eol_t::ch )... >::value != bool( R ) >::bump( in, count );
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bytes.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bytes.hpp
new file mode 100644
index 00000000..10c6c85f
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/bytes.hpp
@@ -0,0 +1,46 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_BYTES_HPP
+#define TAO_PEGTL_INTERNAL_BYTES_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< unsigned Num >
+         struct bytes
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::any, Num >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( in.size( 0 ) ) )
+            {
+               if( in.size( Num ) >= Num ) {
+                  in.bump( Num );
+                  return true;
+               }
+               return false;
+            }
+         };
+
+         template< unsigned Num >
+         struct skip_control< bytes< Num > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/control.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/control.hpp
new file mode 100644
index 00000000..dcef9a4e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/control.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_CONTROL_HPP
+#define TAO_PEGTL_INTERNAL_CONTROL_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< template< typename... > class Control, typename... Rules >
+         struct control
+            : control< Control, seq< Rules... > >
+         {
+         };
+
+         template< template< typename... > class Control, typename Rule >
+         struct control< Control, Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< A, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< template< typename... > class Control, typename... Rules >
+         struct skip_control< control< Control, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cr_crlf_eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cr_crlf_eol.hpp
new file mode 100644
index 00000000..ee75ea30
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cr_crlf_eol.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_CR_CRLF_EOL_HPP
+#define TAO_PEGTL_INTERNAL_CR_CRLF_EOL_HPP
+
+#include "../config.hpp"
+#include "../eol_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct cr_crlf_eol
+         {
+            static constexpr int ch = '\r';
+
+            template< typename Input >
+            static eol_pair match( Input& in ) noexcept( noexcept( in.size( 2 ) ) )
+            {
+               eol_pair p = { false, in.size( 2 ) };
+               if( p.second ) {
+                  if( in.peek_char() == '\r' ) {
+                     in.bump_to_next_line( 1 + ( ( p.second > 1 ) && ( in.peek_char( 1 ) == '\n' ) ) );
+                     p.first = true;
+                  }
+               }
+               return p;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cr_eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cr_eol.hpp
new file mode 100644
index 00000000..1ad25f80
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cr_eol.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_CR_EOL_HPP
+#define TAO_PEGTL_INTERNAL_CR_EOL_HPP
+
+#include "../config.hpp"
+#include "../eol_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct cr_eol
+         {
+            static constexpr int ch = '\r';
+
+            template< typename Input >
+            static eol_pair match( Input& in ) noexcept( noexcept( in.size( 1 ) ) )
+            {
+               eol_pair p = { false, in.size( 1 ) };
+               if( p.second ) {
+                  if( in.peek_char() == '\r' ) {
+                     in.bump_to_next_line();
+                     p.first = true;
+                  }
+               }
+               return p;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/crlf_eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/crlf_eol.hpp
new file mode 100644
index 00000000..21556ad4
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/crlf_eol.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_CRLF_EOL_HPP
+#define TAO_PEGTL_INTERNAL_CRLF_EOL_HPP
+
+#include "../config.hpp"
+#include "../eol_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct crlf_eol
+         {
+            static constexpr int ch = '\n';
+
+            template< typename Input >
+            static eol_pair match( Input& in ) noexcept( noexcept( in.size( 2 ) ) )
+            {
+               eol_pair p = { false, in.size( 2 ) };
+               if( p.second > 1 ) {
+                  if( ( in.peek_char() == '\r' ) && ( in.peek_char( 1 ) == '\n' ) ) {
+                     in.bump_to_next_line( 2 );
+                     p.first = true;
+                  }
+               }
+               return p;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cstream_reader.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cstream_reader.hpp
new file mode 100644
index 00000000..412d45e3
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cstream_reader.hpp
@@ -0,0 +1,50 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_CSTREAM_READER_HPP
+#define TAO_PEGTL_INTERNAL_CSTREAM_READER_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <cstdio>
+
+#include "../config.hpp"
+#include "../input_error.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct cstream_reader
+         {
+            explicit cstream_reader( std::FILE* s ) noexcept
+               : m_cstream( s )
+            {
+               assert( m_cstream != nullptr );
+            }
+
+            std::size_t operator()( char* buffer, const std::size_t length ) const
+            {
+               if( const auto r = std::fread( buffer, 1, length, m_cstream ) ) {
+                  return r;
+               }
+               if( std::feof( m_cstream ) != 0 ) {
+                  return 0;
+               }
+               // Please contact us if you know how to provoke the following exception.
+               // The example on cppreference.com doesn't work, at least not on macOS.
+               TAO_PEGTL_THROW_INPUT_ERROR( "error in fread() from cstream" );  // LCOV_EXCL_LINE
+            }
+
+            std::FILE* m_cstream;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cstring_reader.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cstring_reader.hpp
new file mode 100644
index 00000000..c3a8a08e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/cstring_reader.hpp
@@ -0,0 +1,49 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_CSTRING_READER_HPP
+#define TAO_PEGTL_INTERNAL_CSTRING_READER_HPP
+
+#include <cassert>
+#include <cstddef>
+
+#include "../config.hpp"
+#include "../input_error.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct cstring_reader
+         {
+            explicit cstring_reader( const char* zero_terminated ) noexcept
+               : m_cstring( zero_terminated )
+            {
+               assert( m_cstring != nullptr );
+            }
+
+            std::size_t operator()( char* buffer, const std::size_t length ) noexcept
+            {
+               std::size_t i = 0;
+               char c;
+
+               while( ( i < length ) && ( ( c = m_cstring[ i ] ) != 0 ) ) {
+                  *buffer++ = c;
+                  ++i;
+               }
+               m_cstring += i;
+               return i;
+            }
+
+            const char* m_cstring;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle.hpp
new file mode 100644
index 00000000..f0bd799c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle.hpp
@@ -0,0 +1,85 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DEMANGLE_HPP
+#define TAO_PEGTL_INTERNAL_DEMANGLE_HPP
+
+#include <string>
+#include <typeinfo>
+
+#include "../config.hpp"
+
+#if defined( __clang__ )
+#if __has_feature( cxx_rtti )
+#define TAO_PEGTL_RTTI_ENABLED
+#endif
+#elif defined( __GNUC__ )
+#if defined( __GXX_RTTI )
+#define TAO_PEGTL_RTTI_ENABLED
+#endif
+#elif defined( _MSC_VER )
+#if defined( _CPPRTTI )
+#define TAO_PEGTL_RTTI_ENABLED
+#endif
+#else
+#define TAO_PEGTL_RTTI_ENABLED
+#endif
+
+#if !defined( TAO_PEGTL_RTTI_ENABLED )
+#include <cassert>
+#include <cstring>
+#endif
+
+#if defined( TAO_PEGTL_RTTI_ENABLED )
+#if defined( __GLIBCXX__ )
+#define TAO_PEGTL_USE_CXXABI_DEMANGLE
+#elif defined( __has_include )
+#if __has_include( <cxxabi.h> )
+#define TAO_PEGTL_USE_CXXABI_DEMANGLE
+#endif
+#endif
+#endif
+
+#if defined( TAO_PEGTL_USE_CXXABI_DEMANGLE )
+#include "demangle_cxxabi.hpp"
+#undef TAO_PEGTL_USE_CXXABI_DEMANGLE
+#else
+#include "demangle_nop.hpp"
+#endif
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename T >
+         std::string demangle()
+         {
+#if defined( TAO_PEGTL_RTTI_ENABLED )
+            return demangle( typeid( T ).name() );
+#else
+            const char* start = nullptr;
+            const char* stop = nullptr;
+#if defined( __clang__ ) || defined( __GNUC__ )
+            start = std::strchr( __PRETTY_FUNCTION__, '=' ) + 2;
+            stop = std::strrchr( start, ';' );
+#elif defined( _MSC_VER )
+            start = std::strstr( __FUNCSIG__, "demangle<" ) + ( sizeof( "demangle<" ) - 1 );
+            stop = std::strrchr( start, '>' );
+#else
+            static_assert( false, "expected to use rtti with this compiler" );
+#endif
+            assert( start != nullptr );
+            assert( stop != nullptr );
+            return { start, std::size_t( stop - start ) };
+#endif
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_cxxabi.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_cxxabi.hpp
new file mode 100644
index 00000000..5027e7ff
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_cxxabi.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DEMANGLE_CXXABI_HPP
+#define TAO_PEGTL_INTERNAL_DEMANGLE_CXXABI_HPP
+
+#include <cstdlib>
+#include <cxxabi.h>
+#include <memory>
+#include <string>
+
+#include "../config.hpp"
+
+#include "demangle_sanitise.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline std::string demangle( const char* symbol )
+         {
+            const std::unique_ptr< char, decltype( &std::free ) > demangled( abi::__cxa_demangle( symbol, nullptr, nullptr, nullptr ), &std::free );
+            if( !demangled ) {
+               return symbol;
+            }
+            std::string result( demangled.get() );
+#ifdef TAO_PEGTL_PRETTY_DEMANGLE
+            demangle_sanitise_chars( result );  // LCOV_EXCL_LINE
+#endif
+            return result;
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_nop.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_nop.hpp
new file mode 100644
index 00000000..caea50ec
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_nop.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DEMANGLE_NOP_HPP
+#define TAO_PEGTL_INTERNAL_DEMANGLE_NOP_HPP
+
+#include <string>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline std::string demangle( const char* symbol )
+         {
+            return symbol;
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_sanitise.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_sanitise.hpp
new file mode 100644
index 00000000..378f5b02
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/demangle_sanitise.hpp
@@ -0,0 +1,48 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DEMANGLE_SANITISE_HPP
+#define TAO_PEGTL_INTERNAL_DEMANGLE_SANITISE_HPP
+
+#include <string>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline void demangle_sanitise_chars( std::string& s )
+         {
+            std::string::size_type p;
+            while( ( p = s.find( "(char)" ) ) != std::string::npos ) {
+               int c = 0;
+               std::string::size_type q;
+               for( q = p + 6; ( q < s.size() ) && ( s[ q ] >= '0' ) && ( s[ q ] <= '9' ); ++q ) {
+                  c *= 10;
+                  c += s[ q ] - '0';
+               }
+               if( c == '\'' ) {
+                  s.replace( p, q - p, "'\\''" );
+               }
+               else if( c == '\\' ) {
+                  s.replace( p, q - p, "'\\\\'" );
+               }
+               else if( ( c < 32 ) || ( c > 126 ) ) {
+                  s.replace( p, 6, std::string() );
+               }
+               else {
+                  s.replace( p, q - p, std::string( 1, '\'' ) + char( c ) + '\'' );
+               }
+            }
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/disable.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/disable.hpp
new file mode 100644
index 00000000..3f6238e3
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/disable.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DISABLE_HPP
+#define TAO_PEGTL_INTERNAL_DISABLE_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct disable
+            : disable< seq< Rules... > >
+         {
+         };
+
+         template< typename Rule >
+         struct disable< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule >;
+
+            template< apply_mode,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< apply_mode::nothing, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< disable< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/discard.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/discard.hpp
new file mode 100644
index 00000000..05ca46f0
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/discard.hpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DISCARD_HPP
+#define TAO_PEGTL_INTERNAL_DISCARD_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct discard
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept
+            {
+               static_assert( noexcept( in.discard() ), "an input's discard()-method must be noexcept" );
+               in.discard();
+               return true;
+            }
+         };
+
+         template<>
+         struct skip_control< discard > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/dusel_mode.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/dusel_mode.hpp
new file mode 100644
index 00000000..a0e0aba2
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/dusel_mode.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DUSEL_MODE_HPP
+#define TAO_PEGTL_INTERNAL_DUSEL_MODE_HPP
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         enum class dusel_mode : char
+         {
+            nothing = 0,
+            control = 1,
+            control_and_apply_void = 2,
+            control_and_apply_bool = 3,
+            control_and_apply0_void = 4,
+            control_and_apply0_bool = 5,
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/duseltronik.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/duseltronik.hpp
new file mode 100644
index 00000000..fc58270a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/duseltronik.hpp
@@ -0,0 +1,188 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DUSELTRONIK_HPP
+#define TAO_PEGTL_INTERNAL_DUSELTRONIK_HPP
+
+#include "../apply_mode.hpp"
+#include "../config.hpp"
+#include "../rewind_mode.hpp"
+
+#include "dusel_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   dusel_mode = dusel_mode::nothing >
+         struct duseltronik;
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control >
+         struct duseltronik< Rule, A, M, Action, Control, dusel_mode::nothing >
+         {
+            template< typename Input, typename... States >
+            static auto match( Input& in, States&&... st )
+               -> decltype( Rule::template match< A, M, Action, Control >( in, st... ), true )
+            {
+               return Rule::template match< A, M, Action, Control >( in, st... );
+            }
+
+            // NOTE: The additional "int = 0" is a work-around for missing expression SFINAE in VS2015.
+
+            template< typename Input, typename... States, int = 0 >
+            static auto match( Input& in, States&&... /*unused*/ )
+               -> decltype( Rule::match( in ), true )
+            {
+               return Rule::match( in );
+            }
+         };
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control >
+         struct duseltronik< Rule, A, M, Action, Control, dusel_mode::control >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               Control< Rule >::start( static_cast< const Input& >( in ), st... );
+
+               if( duseltronik< Rule, A, M, Action, Control, dusel_mode::nothing >::match( in, st... ) ) {
+                  Control< Rule >::success( static_cast< const Input& >( in ), st... );
+                  return true;
+               }
+               Control< Rule >::failure( static_cast< const Input& >( in ), st... );
+               return false;
+            }
+         };
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control >
+         struct duseltronik< Rule, A, M, Action, Control, dusel_mode::control_and_apply_void >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< rewind_mode::required >();
+
+               Control< Rule >::start( static_cast< const Input& >( in ), st... );
+
+               if( duseltronik< Rule, A, rewind_mode::active, Action, Control, dusel_mode::nothing >::match( in, st... ) ) {
+                  Control< Rule >::template apply< Action >( m.iterator(), static_cast< const Input& >( in ), st... );
+                  Control< Rule >::success( static_cast< const Input& >( in ), st... );
+                  return m( true );
+               }
+               Control< Rule >::failure( static_cast< const Input& >( in ), st... );
+               return false;
+            }
+         };
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control >
+         struct duseltronik< Rule, A, M, Action, Control, dusel_mode::control_and_apply_bool >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< rewind_mode::required >();
+
+               Control< Rule >::start( static_cast< const Input& >( in ), st... );
+
+               if( duseltronik< Rule, A, rewind_mode::active, Action, Control, dusel_mode::nothing >::match( in, st... ) ) {
+                  if( Control< Rule >::template apply< Action >( m.iterator(), static_cast< const Input& >( in ), st... ) ) {
+                     Control< Rule >::success( static_cast< const Input& >( in ), st... );
+                     return m( true );
+                  }
+               }
+               Control< Rule >::failure( static_cast< const Input& >( in ), st... );
+               return false;
+            }
+         };
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control >
+         struct duseltronik< Rule, A, M, Action, Control, dusel_mode::control_and_apply0_void >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               Control< Rule >::start( static_cast< const Input& >( in ), st... );
+
+               if( duseltronik< Rule, A, M, Action, Control, dusel_mode::nothing >::match( in, st... ) ) {
+                  Control< Rule >::template apply0< Action >( static_cast< const Input& >( in ), st... );
+                  Control< Rule >::success( static_cast< const Input& >( in ), st... );
+                  return true;
+               }
+               Control< Rule >::failure( static_cast< const Input& >( in ), st... );
+               return false;
+            }
+         };
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control >
+         struct duseltronik< Rule, A, M, Action, Control, dusel_mode::control_and_apply0_bool >
+         {
+            template< typename Input, typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< rewind_mode::required >();
+
+               Control< Rule >::start( static_cast< const Input& >( in ), st... );
+
+               if( duseltronik< Rule, A, rewind_mode::active, Action, Control, dusel_mode::nothing >::match( in, st... ) ) {
+                  if( Control< Rule >::template apply0< Action >( static_cast< const Input& >( in ), st... ) ) {
+                     Control< Rule >::success( static_cast< const Input& >( in ), st... );
+                     return m( true );
+                  }
+               }
+               Control< Rule >::failure( static_cast< const Input& >( in ), st... );
+               return false;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/enable.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/enable.hpp
new file mode 100644
index 00000000..0b7b2d42
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/enable.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ENABLE_HPP
+#define TAO_PEGTL_INTERNAL_ENABLE_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct enable
+            : enable< seq< Rules... > >
+         {
+         };
+
+         template< typename Rule >
+         struct enable< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule >;
+
+            template< apply_mode,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< apply_mode::action, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< enable< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian.hpp
new file mode 100644
index 00000000..2aa2c534
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian.hpp
@@ -0,0 +1,70 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ENDIAN_HPP
+#define TAO_PEGTL_INTERNAL_ENDIAN_HPP
+
+#include <cstdint>
+#include <cstring>
+
+#include "../config.hpp"
+
+#if defined( _WIN32 ) && !defined( __MINGW32__ )
+#include "endian_win.hpp"
+#else
+#include "endian_gcc.hpp"
+#endif
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename N >
+         N h_to_be( const N n ) noexcept
+         {
+            return N( to_and_from_be< sizeof( N ) >::convert( n ) );
+         }
+
+         template< typename N >
+         N be_to_h( const N n ) noexcept
+         {
+            return h_to_be( n );
+         }
+
+         template< typename N >
+         N be_to_h( const void* p ) noexcept
+         {
+            N n;
+            std::memcpy( &n, p, sizeof( n ) );
+            return internal::be_to_h( n );
+         }
+
+         template< typename N >
+         N h_to_le( const N n ) noexcept
+         {
+            return N( to_and_from_le< sizeof( N ) >::convert( n ) );
+         }
+
+         template< typename N >
+         N le_to_h( const N n ) noexcept
+         {
+            return h_to_le( n );
+         }
+
+         template< typename N >
+         N le_to_h( const void* p ) noexcept
+         {
+            N n;
+            std::memcpy( &n, p, sizeof( n ) );
+            return internal::le_to_h( n );
+         }
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian_gcc.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian_gcc.hpp
new file mode 100644
index 00000000..2e180f09
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian_gcc.hpp
@@ -0,0 +1,214 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ENDIAN_GCC_HPP
+#define TAO_PEGTL_INTERNAL_ENDIAN_GCC_HPP
+
+#include <cstdint>
+#include <cstring>
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+#if !defined( __BYTE_ORDER__ )
+#error No byte order defined!
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+
+         template< std::size_t S >
+         struct to_and_from_be
+         {
+            template< typename T >
+            static T convert( const T n ) noexcept
+            {
+               return n;
+            }
+         };
+
+         template< std::size_t S >
+         struct to_and_from_le;
+
+         template<>
+         struct to_and_from_le< 1 >
+         {
+            static std::uint8_t convert( const std::uint8_t n ) noexcept
+            {
+               return n;
+            }
+
+            static std::int8_t convert( const std::int8_t n ) noexcept
+            {
+               return n;
+            }
+         };
+
+         template<>
+         struct to_and_from_le< 2 >
+         {
+            static std::int16_t convert( const std::int16_t n ) noexcept
+            {
+               return static_cast< std::int16_t >( __builtin_bswap16( static_cast< std::uint16_t >( n ) ) );
+            }
+
+            static std::uint16_t convert( const std::uint16_t n ) noexcept
+            {
+               return __builtin_bswap16( n );
+            }
+         };
+
+         template<>
+         struct to_and_from_le< 4 >
+         {
+            static float convert( float n ) noexcept
+            {
+               std::uint32_t u;
+               std::memcpy( &u, &n, 4 );
+               u = convert( u );
+               std::memcpy( &n, &u, 4 );
+               return n;
+            }
+
+            static std::int32_t convert( const std::int32_t n ) noexcept
+            {
+               return static_cast< std::int32_t >( __builtin_bswap32( static_cast< std::uint32_t >( n ) ) );
+            }
+
+            static std::uint32_t convert( const std::uint32_t n ) noexcept
+            {
+               return __builtin_bswap32( n );
+            }
+         };
+
+         template<>
+         struct to_and_from_le< 8 >
+         {
+            static double convert( double n ) noexcept
+            {
+               std::uint64_t u;
+               std::memcpy( &u, &n, 8 );
+               u = convert( u );
+               std::memcpy( &n, &u, 8 );
+               return n;
+            }
+
+            static std::int64_t convert( const std::int64_t n ) noexcept
+            {
+               return static_cast< std::int64_t >( __builtin_bswap64( static_cast< std::uint64_t >( n ) ) );
+            }
+
+            static std::uint64_t convert( const std::uint64_t n ) noexcept
+            {
+               return __builtin_bswap64( n );
+            }
+         };
+
+#define TAO_PEGTL_NATIVE_ORDER be
+#define TAO_PEGTL_NATIVE_UTF16 utf16_be
+#define TAO_PEGTL_NATIVE_UTF32 utf32_be
+
+#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+         template< std::size_t S >
+         struct to_and_from_le
+         {
+            template< typename T >
+            static T convert( const T n ) noexcept
+            {
+               return n;
+            }
+         };
+
+         template< std::size_t S >
+         struct to_and_from_be;
+
+         template<>
+         struct to_and_from_be< 1 >
+         {
+            static std::int8_t convert( const std::int8_t n ) noexcept
+            {
+               return n;
+            }
+
+            static std::uint8_t convert( const std::uint8_t n ) noexcept
+            {
+               return n;
+            }
+         };
+
+         template<>
+         struct to_and_from_be< 2 >
+         {
+            static std::int16_t convert( const std::int16_t n ) noexcept
+            {
+               return static_cast< std::int16_t >( __builtin_bswap16( static_cast< std::uint16_t >( n ) ) );
+            }
+
+            static std::uint16_t convert( const std::uint16_t n ) noexcept
+            {
+               return __builtin_bswap16( n );
+            }
+         };
+
+         template<>
+         struct to_and_from_be< 4 >
+         {
+            static float convert( float n ) noexcept
+            {
+               std::uint32_t u;
+               std::memcpy( &u, &n, 4 );
+               u = convert( u );
+               std::memcpy( &n, &u, 4 );
+               return n;
+            }
+
+            static std::int32_t convert( const std::int32_t n ) noexcept
+            {
+               return static_cast< std::int32_t >( __builtin_bswap32( static_cast< std::uint32_t >( n ) ) );
+            }
+
+            static std::uint32_t convert( const std::uint32_t n ) noexcept
+            {
+               return __builtin_bswap32( n );
+            }
+         };
+
+         template<>
+         struct to_and_from_be< 8 >
+         {
+            static double convert( double n ) noexcept
+            {
+               std::uint64_t u;
+               std::memcpy( &u, &n, 8 );
+               u = convert( u );
+               std::memcpy( &n, &u, 8 );
+               return n;
+            }
+
+            static std::int64_t convert( const std::int64_t n ) noexcept
+            {
+               return static_cast< std::int64_t >( __builtin_bswap64( static_cast< std::uint64_t >( n ) ) );
+            }
+
+            static std::uint64_t convert( const std::uint64_t n ) noexcept
+            {
+               return __builtin_bswap64( n );
+            }
+         };
+
+#define TAO_PEGTL_NATIVE_ORDER le
+#define TAO_PEGTL_NATIVE_UTF16 utf16_le
+#define TAO_PEGTL_NATIVE_UTF32 utf32_le
+
+#else
+#error Unknown host byte order!
+#endif
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian_win.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian_win.hpp
new file mode 100644
index 00000000..19d62aae
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/endian_win.hpp
@@ -0,0 +1,115 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ENDIAN_WIN_HPP
+#define TAO_PEGTL_INTERNAL_ENDIAN_WIN_HPP
+
+#include <cstdint>
+#include <cstring>
+
+#include <stdlib.h>
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< std::size_t S >
+         struct to_and_from_le
+         {
+            template< typename T >
+            static T convert( const T t ) noexcept
+            {
+               return t;
+            }
+         };
+
+         template< std::size_t S >
+         struct to_and_from_be;
+
+         template<>
+         struct to_and_from_be< 1 >
+         {
+            static std::int8_t convert( const std::int8_t n ) noexcept
+            {
+               return n;
+            }
+
+            static std::uint8_t convert( const std::uint8_t n ) noexcept
+            {
+               return n;
+            }
+         };
+
+         template<>
+         struct to_and_from_be< 2 >
+         {
+            static std::int16_t convert( const std::int16_t n ) noexcept
+            {
+               return std::int16_t( _byteswap_ushort( std::uint16_t( n ) ) );
+            }
+
+            static std::uint16_t convert( const std::uint16_t n ) noexcept
+            {
+               return _byteswap_ushort( n );
+            }
+         };
+
+         template<>
+         struct to_and_from_be< 4 >
+         {
+            static float convert( float n ) noexcept
+            {
+               std::uint32_t u;
+               std::memcpy( &u, &n, 4 );
+               u = convert( u );
+               std::memcpy( &n, &u, 4 );
+               return n;
+            }
+
+            static std::int32_t convert( const std::int32_t n ) noexcept
+            {
+               return std::int32_t( _byteswap_ulong( std::uint32_t( n ) ) );
+            }
+
+            static std::uint32_t convert( const std::uint32_t n ) noexcept
+            {
+               return _byteswap_ulong( n );
+            }
+         };
+
+         template<>
+         struct to_and_from_be< 8 >
+         {
+            static double convert( double n ) noexcept
+            {
+               std::uint64_t u;
+               std::memcpy( &u, &n, 8 );
+               u = convert( u );
+               std::memcpy( &n, &u, 8 );
+               return n;
+            }
+
+            static std::int64_t convert( const std::int64_t n ) noexcept
+            {
+               return std::int64_t( _byteswap_uint64( std::uint64_t( n ) ) );
+            }
+
+            static std::uint64_t convert( const std::uint64_t n ) noexcept
+            {
+               return _byteswap_uint64( n );
+            }
+         };
+
+#define TAO_PEGTL_NATIVE_ORDER le
+#define TAO_PEGTL_NATIVE_UTF16 utf16_le
+#define TAO_PEGTL_NATIVE_UTF32 utf32_le
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eof.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eof.hpp
new file mode 100644
index 00000000..b3a7542a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eof.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_EOF_HPP
+#define TAO_PEGTL_INTERNAL_EOF_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct eof
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( in.empty() ) )
+            {
+               return in.empty();
+            }
+         };
+
+         template<>
+         struct skip_control< eof > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eol.hpp
new file mode 100644
index 00000000..3878f95c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eol.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_EOL_HPP
+#define TAO_PEGTL_INTERNAL_EOL_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct eol
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Input::eol_t::match( in ) ) )
+            {
+               return Input::eol_t::match( in ).first;
+            }
+         };
+
+         template<>
+         struct skip_control< eol > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eolf.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eolf.hpp
new file mode 100644
index 00000000..a3fae89e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/eolf.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_EOLF_HPP
+#define TAO_PEGTL_INTERNAL_EOLF_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct eolf
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Input::eol_t::match( in ) ) )
+            {
+               const auto p = Input::eol_t::match( in );
+               return p.first || ( !p.second );
+            }
+         };
+
+         template<>
+         struct skip_control< eolf > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_mapper_posix.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_mapper_posix.hpp
new file mode 100644
index 00000000..c77529e1
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_mapper_posix.hpp
@@ -0,0 +1,95 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_FILE_MAPPER_POSIX_HPP
+#define TAO_PEGTL_INTERNAL_FILE_MAPPER_POSIX_HPP
+
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include "../config.hpp"
+
+#include "file_opener.hpp"
+
+#include "../input_error.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         class file_mapper
+         {
+         public:
+            explicit file_mapper( const char* filename )
+               : file_mapper( file_opener( filename ) )
+            {
+            }
+
+            explicit file_mapper( const file_opener& reader )
+               : m_size( reader.size() ),
+                 m_data( static_cast< const char* >( ::mmap( nullptr, m_size, PROT_READ, MAP_PRIVATE, reader.m_fd, 0 ) ) )
+            {
+               if( ( m_size != 0 ) && ( intptr_t( m_data ) == -1 ) ) {
+                  TAO_PEGTL_THROW_INPUT_ERROR( "unable to mmap() file " << reader.m_source << " descriptor " << reader.m_fd );
+               }
+            }
+
+            file_mapper( const file_mapper& ) = delete;
+            file_mapper( file_mapper&& ) = delete;
+
+            ~file_mapper() noexcept
+            {
+               // Legacy C interface requires pointer-to-mutable but does not write through the pointer.
+               ::munmap( const_cast< char* >( m_data ), m_size );  // NOLINT
+            }
+
+            void operator=( const file_mapper& ) = delete;
+            void operator=( file_mapper&& ) = delete;
+
+            bool empty() const noexcept
+            {
+               return m_size == 0;
+            }
+
+            std::size_t size() const noexcept
+            {
+               return m_size;
+            }
+
+            using iterator = const char*;
+            using const_iterator = const char*;
+
+            iterator data() const noexcept
+            {
+               return m_data;
+            }
+
+            iterator begin() const noexcept
+            {
+               return m_data;
+            }
+
+            iterator end() const noexcept
+            {
+               return m_data + m_size;
+            }
+
+            std::string string() const
+            {
+               return std::string( m_data, m_size );
+            }
+
+         private:
+            const std::size_t m_size;
+            const char* const m_data;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_opener.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_opener.hpp
new file mode 100644
index 00000000..33eccb63
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_opener.hpp
@@ -0,0 +1,78 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_FILE_OPENER_HPP
+#define TAO_PEGTL_INTERNAL_FILE_OPENER_HPP
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <utility>
+
+#include "../config.hpp"
+#include "../input_error.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct file_opener
+         {
+            explicit file_opener( const char* filename )
+               : m_source( filename ),
+                 m_fd( open() )
+            {
+            }
+
+            file_opener( const file_opener& ) = delete;
+            file_opener( file_opener&& ) = delete;
+
+            ~file_opener() noexcept
+            {
+               ::close( m_fd );
+            }
+
+            void operator=( const file_opener& ) = delete;
+            void operator=( file_opener&& ) = delete;
+
+            std::size_t size() const
+            {
+               struct stat st;  // NOLINT
+               errno = 0;
+               if( ::fstat( m_fd, &st ) < 0 ) {
+                  TAO_PEGTL_THROW_INPUT_ERROR( "unable to fstat() file " << m_source << " descriptor " << m_fd );
+               }
+               return std::size_t( st.st_size );
+            }
+
+            const char* const m_source;
+            const int m_fd;
+
+         private:
+            int open() const
+            {
+               errno = 0;
+               const int fd = ::open( m_source,  // NOLINT
+                                      O_RDONLY
+#ifdef O_CLOEXEC
+                                         | O_CLOEXEC
+#endif
+               );
+               if( fd >= 0 ) {
+                  return fd;
+               }
+               TAO_PEGTL_THROW_INPUT_ERROR( "unable to open() file " << m_source << " for reading" );
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_reader.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_reader.hpp
new file mode 100644
index 00000000..c309aef3
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/file_reader.hpp
@@ -0,0 +1,109 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_FILE_READER_HPP
+#define TAO_PEGTL_INTERNAL_FILE_READER_HPP
+
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "../config.hpp"
+#include "../input_error.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline std::FILE* file_open( const char* filename )
+         {
+            errno = 0;
+#if defined( _MSC_VER )
+            std::FILE* file;
+            if( ::fopen_s( &file, filename, "rb" ) == 0 )
+#elif defined( __MINGW32__ )
+            if( auto* file = std::fopen( filename, "rb" ) )  // NOLINT
+#else
+            if( auto* file = std::fopen( filename, "rbe" ) )  // NOLINT
+#endif
+            {
+               return file;
+            }
+            TAO_PEGTL_THROW_INPUT_ERROR( "unable to fopen() file " << filename << " for reading" );
+         }
+
+         struct file_close
+         {
+            void operator()( FILE* f ) const noexcept
+            {
+               std::fclose( f );  // NOLINT
+            }
+         };
+
+         class file_reader
+         {
+         public:
+            explicit file_reader( const char* filename )
+               : m_source( filename ),
+                 m_file( file_open( m_source ) )
+            {
+            }
+
+            file_reader( FILE* file, const char* filename ) noexcept
+               : m_source( filename ),
+                 m_file( file )
+            {
+            }
+
+            file_reader( const file_reader& ) = delete;
+            file_reader( file_reader&& ) = delete;
+
+            ~file_reader() = default;
+
+            void operator=( const file_reader& ) = delete;
+            void operator=( file_reader&& ) = delete;
+
+            std::size_t size() const
+            {
+               errno = 0;
+               if( std::fseek( m_file.get(), 0, SEEK_END ) != 0 ) {
+                  TAO_PEGTL_THROW_INPUT_ERROR( "unable to fseek() to end of file " << m_source );  // LCOV_EXCL_LINE
+               }
+               errno = 0;
+               const auto s = std::ftell( m_file.get() );
+               if( s < 0 ) {
+                  TAO_PEGTL_THROW_INPUT_ERROR( "unable to ftell() file size of file " << m_source );  // LCOV_EXCL_LINE
+               }
+               errno = 0;
+               if( std::fseek( m_file.get(), 0, SEEK_SET ) != 0 ) {
+                  TAO_PEGTL_THROW_INPUT_ERROR( "unable to fseek() to beginning of file " << m_source );  // LCOV_EXCL_LINE
+               }
+               return std::size_t( s );
+            }
+
+            std::string read() const
+            {
+               std::string nrv;
+               nrv.resize( size() );
+               errno = 0;
+               if( !nrv.empty() && ( std::fread( &nrv[ 0 ], nrv.size(), 1, m_file.get() ) != 1 ) ) {
+                  TAO_PEGTL_THROW_INPUT_ERROR( "unable to fread() file " << m_source << " size " << nrv.size() );  // LCOV_EXCL_LINE
+               }
+               return nrv;
+            }
+
+         private:
+            const char* const m_source;
+            const std::unique_ptr< std::FILE, file_close > m_file;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_apply.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_apply.hpp
new file mode 100644
index 00000000..f0daf969
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_apply.hpp
@@ -0,0 +1,33 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_HAS_APPLY_HPP
+#define TAO_PEGTL_INTERNAL_HAS_APPLY_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename, typename, template< typename... > class, typename... >
+         struct has_apply
+            : std::false_type
+         {};
+
+         template< typename C, template< typename... > class Action, typename... S >
+         struct has_apply< C, decltype( C::template apply< Action >( std::declval< S >()... ) ), Action, S... >
+            : std::true_type
+         {};
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_apply0.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_apply0.hpp
new file mode 100644
index 00000000..b54c60b2
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_apply0.hpp
@@ -0,0 +1,33 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_HAS_APPLY0_HPP
+#define TAO_PEGTL_INTERNAL_HAS_APPLY0_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename, typename, template< typename... > class, typename... >
+         struct has_apply0
+            : std::false_type
+         {};
+
+         template< typename C, template< typename... > class Action, typename... S >
+         struct has_apply0< C, decltype( C::template apply0< Action >( std::declval< S >()... ) ), Action, S... >
+            : std::true_type
+         {};
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_match.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_match.hpp
new file mode 100644
index 00000000..af3c2bbd
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/has_match.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_HAS_MATCH_HPP
+#define TAO_PEGTL_INTERNAL_HAS_MATCH_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include "../apply_mode.hpp"
+#include "../config.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename,
+                   typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         struct has_match
+            : std::false_type
+         {};
+
+         template< typename Rule,
+                   apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         struct has_match< decltype( Action< Rule >::template match< Rule, A, M, Action, Control >( std::declval< Input& >(), std::declval< States&& >()... ), void() ), Rule, A, M, Action, Control, Input, States... >
+            : std::true_type
+         {};
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/identifier.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/identifier.hpp
new file mode 100644
index 00000000..81942665
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/identifier.hpp
@@ -0,0 +1,30 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_IDENTIFIER_HPP
+#define TAO_PEGTL_INTERNAL_IDENTIFIER_HPP
+
+#include "../config.hpp"
+
+#include "peek_char.hpp"
+#include "ranges.hpp"
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         using identifier_first = ranges< peek_char, 'a', 'z', 'A', 'Z', '_' >;
+         using identifier_other = ranges< peek_char, 'a', 'z', 'A', 'Z', '0', '9', '_' >;
+         using identifier = seq< identifier_first, star< identifier_other > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_apply.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_apply.hpp
new file mode 100644
index 00000000..df2b3061
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_apply.hpp
@@ -0,0 +1,118 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_IF_APPLY_HPP
+#define TAO_PEGTL_INTERNAL_IF_APPLY_HPP
+
+#include "../config.hpp"
+
+#include "apply_single.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/counted.hpp"
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< apply_mode A, typename Rule, typename... Actions >
+         struct if_apply_impl;
+
+         template< typename Rule >
+         struct if_apply_impl< apply_mode::action, Rule >
+         {
+            template< rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< apply_mode::action, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename Rule, typename... Actions >
+         struct if_apply_impl< apply_mode::action, Rule, Actions... >
+         {
+            template< rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               using action_t = typename Input::action_t;
+
+               auto m = in.template mark< rewind_mode::required >();
+
+               if( Control< Rule >::template match< apply_mode::action, rewind_mode::active, Action, Control >( in, st... ) ) {
+                  const action_t i2( m.iterator(), in );
+#ifdef __cpp_fold_expressions
+                  return m( ( apply_single< Actions >::match( i2, st... ) && ... ) );
+#else
+                  bool result = true;
+                  using swallow = bool[];
+                  (void)swallow{ result = result && apply_single< Actions >::match( i2, st... )... };
+                  return m( result );
+#endif
+               }
+               return false;
+            }
+         };
+
+         template< typename Rule, typename... Actions >
+         struct if_apply_impl< apply_mode::nothing, Rule, Actions... >
+         {
+            template< rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< apply_mode::nothing, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename Rule, typename... Actions >
+         struct if_apply
+         {
+            using analyze_t = typename Rule::analyze_t;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return if_apply_impl< A, Rule, Actions... >::template match< M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename Rule, typename... Actions >
+         struct skip_control< if_apply< Rule, Actions... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_missing.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_missing.hpp
new file mode 100644
index 00000000..d0aa8abb
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_missing.hpp
@@ -0,0 +1,72 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_IF_MISSING_HPP
+#define TAO_PEGTL_INTERNAL_IF_MISSING_HPP
+
+#include "../config.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< bool >
+         struct if_missing;
+
+         template<>
+         struct if_missing< true >
+         {
+            template< typename Control,
+                      template< typename... >
+                      class Action,
+                      typename Input,
+                      typename... States >
+            static void apply( Input& in, States&&... st )
+            {
+               auto m = in.template mark< rewind_mode::required >();
+               Control::template apply< Action >( m.iterator(), in, st... );
+            }
+
+            template< typename Control,
+                      template< typename... >
+                      class Action,
+                      typename Input,
+                      typename... States >
+            static void apply0( Input& in, States&&... st )
+            {
+               Control::template apply0< Action >( in, st... );
+            }
+         };
+
+         template<>
+         struct if_missing< false >
+         {
+            template< typename Control,
+                      template< typename... >
+                      class Action,
+                      typename Input,
+                      typename... States >
+            static void apply( Input& /*unused*/, States&&... /*unused*/ )
+            {
+            }
+
+            template< typename Control,
+                      template< typename... >
+                      class Action,
+                      typename Input,
+                      typename... States >
+            static void apply0( Input& /*unused*/, States&&... /*unused*/ )
+            {
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_must.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_must.hpp
new file mode 100644
index 00000000..0cbd08c0
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_must.hpp
@@ -0,0 +1,58 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_IF_MUST_HPP
+#define TAO_PEGTL_INTERNAL_IF_MUST_HPP
+
+#include "../config.hpp"
+
+#include "must.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< bool Default, typename Cond, typename... Rules >
+         struct if_must
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::seq, Default ? 0 : 1, Cond, must< Rules... > >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
+                  Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
+                  return true;
+               }
+               return Default;
+            }
+         };
+
+         template< bool Default, typename Cond, typename... Rules >
+         struct skip_control< if_must< Default, Cond, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_must_else.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_must_else.hpp
new file mode 100644
index 00000000..74db045f
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_must_else.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_IF_MUST_ELSE_HPP
+#define TAO_PEGTL_INTERNAL_IF_MUST_ELSE_HPP
+
+#include "../config.hpp"
+
+#include "if_then_else.hpp"
+#include "must.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Cond, typename Then, typename Else >
+         using if_must_else = if_then_else< Cond, must< Then >, must< Else > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_then_else.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_then_else.hpp
new file mode 100644
index 00000000..7d7b30fa
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/if_then_else.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_IF_THEN_ELSE_HPP
+#define TAO_PEGTL_INTERNAL_IF_THEN_ELSE_HPP
+
+#include "../config.hpp"
+
+#include "not_at.hpp"
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "sor.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Cond, typename Then, typename Else >
+         struct if_then_else
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::sor, seq< Cond, Then >, seq< not_at< Cond >, Else > >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+               using m_t = decltype( m );
+
+               if( Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+                  return m( Control< Then >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) );
+               }
+               return m( Control< Else >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) );
+            }
+         };
+
+         template< typename Cond, typename Then, typename Else >
+         struct skip_control< if_then_else< Cond, Then, Else > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/input_pair.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/input_pair.hpp
new file mode 100644
index 00000000..f586a05c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/input_pair.hpp
@@ -0,0 +1,37 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_INPUT_PAIR_HPP
+#define TAO_PEGTL_INTERNAL_INPUT_PAIR_HPP
+
+#include <cstdint>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Data >
+         struct input_pair
+         {
+            Data data;
+            std::uint8_t size;
+
+            using data_t = Data;
+
+            explicit operator bool() const noexcept
+            {
+               return size > 0;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/integer_sequence.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/integer_sequence.hpp
new file mode 100644
index 00000000..74e461d5
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/integer_sequence.hpp
@@ -0,0 +1,86 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_INTEGER_SEQUENCE_HPP
+#define TAO_PEGTL_INTERNAL_INTEGER_SEQUENCE_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename T, T... Ns >
+         struct integer_sequence
+         {
+            using value_type = T;
+
+            static constexpr std::size_t size() noexcept
+            {
+               return sizeof...( Ns );
+            }
+         };
+
+         template< std::size_t... Ns >
+         using index_sequence = integer_sequence< std::size_t, Ns... >;
+
+         template< bool V, bool E >
+         struct generate_sequence;
+
+         template<>
+         struct generate_sequence< false, true >
+         {
+            template< typename T, T M, T N, std::size_t S, T... Ns >
+            using f = integer_sequence< T, Ns... >;
+         };
+
+         template<>
+         struct generate_sequence< true, true >
+         {
+            template< typename T, T M, T N, std::size_t S, T... Ns >
+            using f = integer_sequence< T, Ns..., S >;
+         };
+
+         template<>
+         struct generate_sequence< false, false >
+         {
+            template< typename T, T M, T N, std::size_t S, T... Ns >
+            using f = typename generate_sequence< ( N & ( M / 2 ) ) != 0, ( M / 2 ) == 0 >::template f< T, M / 2, N, 2 * S, Ns..., ( Ns + S )... >;
+         };
+
+         template<>
+         struct generate_sequence< true, false >
+         {
+            template< typename T, T M, T N, std::size_t S, T... Ns >
+            using f = typename generate_sequence< ( N & ( M / 2 ) ) != 0, ( M / 2 ) == 0 >::template f< T, M / 2, N, 2 * S + 1, Ns..., ( Ns + S )..., 2 * S >;
+         };
+
+         template< typename T, T N >
+         struct memoize_sequence
+         {
+            static_assert( N < T( 1 << 20 ), "N too large" );
+            using type = typename generate_sequence< false, false >::template f< T, ( N < T( 1 << 1 ) ) ? T( 1 << 1 ) : ( N < T( 1 << 2 ) ) ? T( 1 << 2 ) : ( N < T( 1 << 3 ) ) ? T( 1 << 3 ) : ( N < T( 1 << 4 ) ) ? T( 1 << 4 ) : ( N < T( 1 << 5 ) ) ? T( 1 << 5 ) : ( N < T( 1 << 6 ) ) ? T( 1 << 6 ) : ( N < T( 1 << 7 ) ) ? T( 1 << 7 ) : ( N < T( 1 << 8 ) ) ? T( 1 << 8 ) : ( N < T( 1 << 9 ) ) ? T( 1 << 9 ) : ( N < T( 1 << 10 ) ) ? T( 1 << 10 ) : ( N < T( 1 << 11 ) ) ? T( 1 << 11 ) : ( N < T( 1 << 12 ) ) ? T( 1 << 12 ) : ( N < T( 1 << 13 ) ) ? T( 1 << 13 ) : ( N < T( 1 << 14 ) ) ? T( 1 << 14 ) : ( N < T( 1 << 15 ) ) ? T( 1 << 15 ) : ( N < T( 1 << 16 ) ) ? T( 1 << 16 ) : ( N < T( 1 << 17 ) ) ? T( 1 << 17 ) : ( N < T( 1 << 18 ) ) ? T( 1 << 18 ) : ( N < T( 1 << 19 ) ) ? T( 1 << 19 ) : T( 1 << 20 ), N, 0 >;
+         };
+
+         template< typename T, T N >
+         using make_integer_sequence = typename memoize_sequence< T, N >::type;
+
+         template< std::size_t N >
+         using make_index_sequence = make_integer_sequence< std::size_t, N >;
+
+         template< typename... Ts >
+         using index_sequence_for = make_index_sequence< sizeof...( Ts ) >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/istream_reader.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/istream_reader.hpp
new file mode 100644
index 00000000..77744e0b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/istream_reader.hpp
@@ -0,0 +1,47 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ISTREAM_READER_HPP
+#define TAO_PEGTL_INTERNAL_ISTREAM_READER_HPP
+
+#include <istream>
+
+#include "../config.hpp"
+#include "../input_error.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct istream_reader
+         {
+            explicit istream_reader( std::istream& s ) noexcept
+               : m_istream( s )
+            {
+            }
+
+            std::size_t operator()( char* buffer, const std::size_t length )
+            {
+               m_istream.read( buffer, std::streamsize( length ) );
+
+               if( const auto r = m_istream.gcount() ) {
+                  return std::size_t( r );
+               }
+               if( m_istream.eof() ) {
+                  return 0;
+               }
+               TAO_PEGTL_THROW_INPUT_ERROR( "error in istream.read()" );
+            }
+
+            std::istream& m_istream;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/istring.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/istring.hpp
new file mode 100644
index 00000000..9aabba8f
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/istring.hpp
@@ -0,0 +1,107 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ISTRING_HPP
+#define TAO_PEGTL_INTERNAL_ISTRING_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "bump_help.hpp"
+#include "result_on_found.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< char C >
+         using is_alpha = std::integral_constant< bool, ( ( 'a' <= C ) && ( C <= 'z' ) ) || ( ( 'A' <= C ) && ( C <= 'Z' ) ) >;
+
+         template< char C, bool A = is_alpha< C >::value >
+         struct ichar_equal;
+
+         template< char C >
+         struct ichar_equal< C, true >
+         {
+            static bool match( const char c ) noexcept
+            {
+               return ( C | 0x20 ) == ( c | 0x20 );
+            }
+         };
+
+         template< char C >
+         struct ichar_equal< C, false >
+         {
+            static bool match( const char c ) noexcept
+            {
+               return c == C;
+            }
+         };
+
+         template< char... Cs >
+         struct istring_equal;
+
+         template<>
+         struct istring_equal<>
+         {
+            static bool match( const char* /*unused*/ ) noexcept
+            {
+               return true;
+            }
+         };
+
+         template< char C, char... Cs >
+         struct istring_equal< C, Cs... >
+         {
+            static bool match( const char* r ) noexcept
+            {
+               return ichar_equal< C >::match( *r ) && istring_equal< Cs... >::match( r + 1 );
+            }
+         };
+
+         template< char... Cs >
+         struct istring;
+
+         template<>
+         struct istring<>
+            : trivial< true >
+         {
+         };
+
+         template< char... Cs >
+         struct istring
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::any, sizeof...( Cs ) >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( in.size( 0 ) ) )
+            {
+               if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
+                  if( istring_equal< Cs... >::match( in.current() ) ) {
+                     bump_help< result_on_found::success, Input, char, Cs... >( in, sizeof...( Cs ) );
+                     return true;
+                  }
+               }
+               return false;
+            }
+         };
+
+         template< char... Cs >
+         struct skip_control< istring< Cs... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/iterator.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/iterator.hpp
new file mode 100644
index 00000000..cf2cd98f
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/iterator.hpp
@@ -0,0 +1,60 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ITERATOR_HPP
+#define TAO_PEGTL_INTERNAL_ITERATOR_HPP
+
+#include <cstdlib>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct iterator
+         {
+            iterator() noexcept = default;
+
+            explicit iterator( const char* in_data ) noexcept
+               : data( in_data )
+            {
+            }
+
+            iterator( const char* in_data, const std::size_t in_byte, const std::size_t in_line, const std::size_t in_byte_in_line ) noexcept
+               : data( in_data ),
+                 byte( in_byte ),
+                 line( in_line ),
+                 byte_in_line( in_byte_in_line )
+            {
+            }
+
+            iterator( const iterator& ) = default;
+            iterator( iterator&& ) = default;
+
+            ~iterator() = default;
+
+            iterator& operator=( const iterator& ) = default;
+            iterator& operator=( iterator&& ) = default;
+
+            void reset() noexcept
+            {
+               *this = iterator();
+            }
+
+            const char* data = nullptr;
+
+            std::size_t byte = 0;
+            std::size_t line = 1;
+            std::size_t byte_in_line = 0;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/lf_crlf_eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/lf_crlf_eol.hpp
new file mode 100644
index 00000000..042c7bef
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/lf_crlf_eol.hpp
@@ -0,0 +1,45 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_LF_CRLF_EOL_HPP
+#define TAO_PEGTL_INTERNAL_LF_CRLF_EOL_HPP
+
+#include "../config.hpp"
+#include "../eol_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct lf_crlf_eol
+         {
+            static constexpr int ch = '\n';
+
+            template< typename Input >
+            static eol_pair match( Input& in ) noexcept( noexcept( in.size( 2 ) ) )
+            {
+               eol_pair p = { false, in.size( 2 ) };
+               if( p.second ) {
+                  const auto a = in.peek_char();
+                  if( a == '\n' ) {
+                     in.bump_to_next_line();
+                     p.first = true;
+                  }
+                  else if( ( a == '\r' ) && ( p.second > 1 ) && ( in.peek_char( 1 ) == '\n' ) ) {
+                     in.bump_to_next_line( 2 );
+                     p.first = true;
+                  }
+               }
+               return p;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/lf_eol.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/lf_eol.hpp
new file mode 100644
index 00000000..566442cf
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/lf_eol.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_LF_EOL_HPP
+#define TAO_PEGTL_INTERNAL_LF_EOL_HPP
+
+#include "../config.hpp"
+#include "../eol_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct lf_eol
+         {
+            static constexpr int ch = '\n';
+
+            template< typename Input >
+            static eol_pair match( Input& in ) noexcept( noexcept( in.size( 1 ) ) )
+            {
+               eol_pair p = { false, in.size( 1 ) };
+               if( p.second ) {
+                  if( in.peek_char() == '\n' ) {
+                     in.bump_to_next_line();
+                     p.first = true;
+                  }
+               }
+               return p;
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list.hpp
new file mode 100644
index 00000000..c0a5c06c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_LIST_HPP
+#define TAO_PEGTL_INTERNAL_LIST_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename Sep >
+         using list = seq< Rule, star< Sep, Rule > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_must.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_must.hpp
new file mode 100644
index 00000000..9f03ed5f
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_must.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_LIST_MUST_HPP
+#define TAO_PEGTL_INTERNAL_LIST_MUST_HPP
+
+#include "../config.hpp"
+
+#include "must.hpp"
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename Sep >
+         using list_must = seq< Rule, star< Sep, must< Rule > > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_tail.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_tail.hpp
new file mode 100644
index 00000000..fca4119c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_tail.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_LIST_TAIL_HPP
+#define TAO_PEGTL_INTERNAL_LIST_TAIL_HPP
+
+#include "../config.hpp"
+
+#include "list.hpp"
+#include "opt.hpp"
+#include "seq.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename Sep >
+         using list_tail = seq< list< Rule, Sep >, opt< Sep > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_tail_pad.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_tail_pad.hpp
new file mode 100644
index 00000000..006e3c11
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/list_tail_pad.hpp
@@ -0,0 +1,30 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_LIST_TAIL_PAD_HPP
+#define TAO_PEGTL_INTERNAL_LIST_TAIL_PAD_HPP
+
+#include "../config.hpp"
+
+#include "list.hpp"
+#include "opt.hpp"
+#include "pad.hpp"
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename Sep, typename Pad >
+         using list_tail_pad = seq< list< Rule, pad< Sep, Pad > >, opt< star< Pad >, Sep > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/marker.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/marker.hpp
new file mode 100644
index 00000000..a358978a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/marker.hpp
@@ -0,0 +1,99 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_MARKER_HPP
+#define TAO_PEGTL_INTERNAL_MARKER_HPP
+
+#include "../config.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Iterator, rewind_mode M >
+         class marker
+         {
+         public:
+            static constexpr rewind_mode next_rewind_mode = M;
+
+            explicit marker( const Iterator& /*unused*/ ) noexcept
+            {
+            }
+
+            marker( const marker& ) = delete;
+
+            marker( marker&& /*unused*/ ) noexcept
+            {
+            }
+
+            ~marker() = default;
+
+            void operator=( const marker& ) = delete;
+            void operator=( marker&& ) = delete;
+
+            bool operator()( const bool result ) const noexcept
+            {
+               return result;
+            }
+         };
+
+         template< typename Iterator >
+         class marker< Iterator, rewind_mode::required >
+         {
+         public:
+            static constexpr rewind_mode next_rewind_mode = rewind_mode::active;
+
+            explicit marker( Iterator& i ) noexcept
+               : m_saved( i ),
+                 m_input( &i )
+            {
+            }
+
+            marker( const marker& ) = delete;
+
+            marker( marker&& i ) noexcept
+               : m_saved( i.m_saved ),
+                 m_input( i.m_input )
+            {
+               i.m_input = nullptr;
+            }
+
+            ~marker() noexcept
+            {
+               if( m_input != nullptr ) {
+                  ( *m_input ) = m_saved;
+               }
+            }
+
+            void operator=( const marker& ) = delete;
+            void operator=( marker&& ) = delete;
+
+            bool operator()( const bool result ) noexcept
+            {
+               if( result ) {
+                  m_input = nullptr;
+                  return true;
+               }
+               return false;
+            }
+
+            const Iterator& iterator() const noexcept
+            {
+               return m_saved;
+            }
+
+         private:
+            const Iterator m_saved;
+            Iterator* m_input;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/must.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/must.hpp
new file mode 100644
index 00000000..3572728d
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/must.hpp
@@ -0,0 +1,70 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_MUST_HPP
+#define TAO_PEGTL_INTERNAL_MUST_HPP
+
+#include "../config.hpp"
+
+#include "raise.hpp"
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         // The general case applies must<> to each of the
+         // rules in the 'Rules' parameter pack individually.
+
+         template< typename... Rules >
+         struct must
+            : seq< must< Rules >... >
+         {
+         };
+
+         // While in theory the implementation for a single rule could
+         // be simplified to must< Rule > = sor< Rule, raise< Rule > >, this
+         // would result in some unnecessary run-time overhead.
+
+         template< typename Rule >
+         struct must< Rule >
+         {
+            using analyze_t = typename Rule::analyze_t;
+
+            template< apply_mode A,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
+                  raise< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... );
+               }
+               return true;
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< must< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/not_at.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/not_at.hpp
new file mode 100644
index 00000000..e1ba9be8
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/not_at.hpp
@@ -0,0 +1,67 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_NOT_AT_HPP
+#define TAO_PEGTL_INTERNAL_NOT_AT_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct not_at
+            : not_at< seq< Rules... > >
+         {
+         };
+
+         template<>
+         struct not_at<>
+            : trivial< false >
+         {
+         };
+
+         template< typename Rule >
+         struct not_at< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt, Rule >;
+
+            template< apply_mode,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               const auto m = in.template mark< rewind_mode::required >();
+               return !Control< Rule >::template match< apply_mode::nothing, rewind_mode::active, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< not_at< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/one.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/one.hpp
new file mode 100644
index 00000000..9734be16
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/one.hpp
@@ -0,0 +1,77 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_ONE_HPP
+#define TAO_PEGTL_INTERNAL_ONE_HPP
+
+#include <algorithm>
+#include <utility>
+
+#include "../config.hpp"
+
+#include "bump_help.hpp"
+#include "result_on_found.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Char >
+         bool contains( const Char c, const std::initializer_list< Char >& l ) noexcept
+         {
+            return std::find( l.begin(), l.end(), c ) != l.end();
+         }
+
+         template< result_on_found R, typename Peek, typename Peek::data_t... Cs >
+         struct one
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Peek::peek( in ) ) )
+            {
+               if( const auto t = Peek::peek( in ) ) {
+                  if( contains( t.data, { Cs... } ) == bool( R ) ) {
+                     bump_help< R, Input, typename Peek::data_t, Cs... >( in, t.size );
+                     return true;
+                  }
+               }
+               return false;
+            }
+         };
+
+         template< result_on_found R, typename Peek, typename Peek::data_t C >
+         struct one< R, Peek, C >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Peek::peek( in ) ) )
+            {
+               if( const auto t = Peek::peek( in ) ) {
+                  if( ( t.data == C ) == bool( R ) ) {
+                     bump_help< R, Input, typename Peek::data_t, C >( in, t.size );
+                     return true;
+                  }
+               }
+               return false;
+            }
+         };
+
+         template< result_on_found R, typename Peek, typename Peek::data_t... Cs >
+         struct skip_control< one< R, Peek, Cs... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/opt.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/opt.hpp
new file mode 100644
index 00000000..0877439b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/opt.hpp
@@ -0,0 +1,69 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_OPT_HPP
+#define TAO_PEGTL_INTERNAL_OPT_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct opt
+            : opt< seq< Rules... > >
+         {
+         };
+
+         template<>
+         struct opt<>
+            : trivial< true >
+         {
+         };
+
+         template< typename Rule >
+         struct opt< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
+               return true;
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< opt< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pad.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pad.hpp
new file mode 100644
index 00000000..bab590a3
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pad.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PAD_HPP
+#define TAO_PEGTL_INTERNAL_PAD_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename Pad1, typename Pad2 = Pad1 >
+         using pad = seq< star< Pad1 >, Rule, star< Pad2 > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pad_opt.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pad_opt.hpp
new file mode 100644
index 00000000..38bab54b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pad_opt.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PAD_OPT_HPP
+#define TAO_PEGTL_INTERNAL_PAD_OPT_HPP
+
+#include "../config.hpp"
+
+#include "opt.hpp"
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename Pad >
+         using pad_opt = seq< star< Pad >, opt< Rule, star< Pad > > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_char.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_char.hpp
new file mode 100644
index 00000000..2ef3f636
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_char.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_CHAR_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_CHAR_HPP
+
+#include <cstddef>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct peek_char
+         {
+            using data_t = char;
+            using pair_t = input_pair< char >;
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.empty() ) )
+            {
+               if( in.empty() ) {
+                  return { 0, 0 };
+               }
+               return { in.peek_char(), 1 };
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_mask_uint.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_mask_uint.hpp
new file mode 100644
index 00000000..257a1cd1
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_mask_uint.hpp
@@ -0,0 +1,62 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_MASK_UINT_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_MASK_UINT_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+#include "read_uint.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename R, typename R::type M >
+         struct peek_mask_uint_impl
+         {
+            using data_t = typename R::type;
+            using pair_t = input_pair< data_t >;
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.size( sizeof( data_t ) ) ) )
+            {
+               if( in.size( sizeof( data_t ) ) < sizeof( data_t ) ) {
+                  return { 0, 0 };
+               }
+               const data_t data = R::read( in.current() ) & M;
+               return { data, sizeof( data_t ) };
+            }
+         };
+
+         template< std::uint16_t M >
+         using peek_mask_uint16_be = peek_mask_uint_impl< read_uint16_be, M >;
+
+         template< std::uint16_t M >
+         using peek_mask_uint16_le = peek_mask_uint_impl< read_uint16_le, M >;
+
+         template< std::uint32_t M >
+         using peek_mask_uint32_be = peek_mask_uint_impl< read_uint32_be, M >;
+
+         template< std::uint32_t M >
+         using peek_mask_uint32_le = peek_mask_uint_impl< read_uint32_le, M >;
+
+         template< std::uint64_t M >
+         using peek_mask_uint64_be = peek_mask_uint_impl< read_uint64_be, M >;
+
+         template< std::uint64_t M >
+         using peek_mask_uint64_le = peek_mask_uint_impl< read_uint64_le, M >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_mask_uint8.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_mask_uint8.hpp
new file mode 100644
index 00000000..a8db5231
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_mask_uint8.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_MASK_UINT8_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_MASK_UINT8_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< std::uint8_t M >
+         struct peek_mask_uint8
+         {
+            using data_t = std::uint8_t;
+            using pair_t = input_pair< std::uint8_t >;
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.empty() ) )
+            {
+               if( in.empty() ) {
+                  return { 0, 0 };
+               }
+               return { std::uint8_t( in.peek_uint8() & M ), 1 };
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_uint.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_uint.hpp
new file mode 100644
index 00000000..973a5404
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_uint.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_UINT_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_UINT_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+#include "read_uint.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename R >
+         struct peek_uint_impl
+         {
+            using data_t = typename R::type;
+            using pair_t = input_pair< data_t >;
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.size( sizeof( data_t ) ) ) )
+            {
+               if( in.size( sizeof( data_t ) ) < sizeof( data_t ) ) {
+                  return { 0, 0 };
+               }
+               const data_t data = R::read( in.current() );
+               return { data, sizeof( data_t ) };
+            }
+         };
+
+         using peek_uint16_be = peek_uint_impl< read_uint16_be >;
+         using peek_uint16_le = peek_uint_impl< read_uint16_le >;
+
+         using peek_uint32_be = peek_uint_impl< read_uint32_be >;
+         using peek_uint32_le = peek_uint_impl< read_uint32_le >;
+
+         using peek_uint64_be = peek_uint_impl< read_uint64_be >;
+         using peek_uint64_le = peek_uint_impl< read_uint64_le >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_uint8.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_uint8.hpp
new file mode 100644
index 00000000..2b8fe073
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_uint8.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_UINT8_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_UINT8_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct peek_uint8
+         {
+            using data_t = std::uint8_t;
+            using pair_t = input_pair< std::uint8_t >;
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.empty() ) )
+            {
+               if( in.empty() ) {
+                  return { 0, 0 };
+               }
+               return { in.peek_uint8(), 1 };
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf16.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf16.hpp
new file mode 100644
index 00000000..490e8e3e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf16.hpp
@@ -0,0 +1,62 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_UTF16_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_UTF16_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+#include "read_uint.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename R >
+         struct peek_utf16_impl
+         {
+            using data_t = char32_t;
+            using pair_t = input_pair< char32_t >;
+
+            using short_t = std::make_unsigned< char16_t >::type;
+
+            static_assert( sizeof( short_t ) == 2, "expected size 2 for 16bit value" );
+            static_assert( sizeof( char16_t ) == 2, "expected size 2 for 16bit value" );
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.size( 4 ) ) )
+            {
+               if( in.size( 2 ) < 2 ) {
+                  return { 0, 0 };
+               }
+               const char32_t t = R::read( in.current() );
+               if( ( t < 0xd800 ) || ( t > 0xdfff ) ) {
+                  return { t, 2 };
+               }
+               if( ( t >= 0xdc00 ) || ( in.size( 4 ) < 4 ) ) {
+                  return { 0, 0 };
+               }
+               const char32_t u = R::read( in.current() + 2 );
+               if( ( u >= 0xdc00 ) && ( u <= 0xdfff ) ) {
+                  const auto cp = ( ( ( t & 0x03ff ) << 10 ) | ( u & 0x03ff ) ) + 0x10000;
+                  return { cp, 4 };
+               }
+               return { 0, 0 };
+            }
+         };
+
+         using peek_utf16_be = peek_utf16_impl< read_uint16_be >;
+         using peek_utf16_le = peek_utf16_impl< read_uint16_le >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf32.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf32.hpp
new file mode 100644
index 00000000..7ddeba6d
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf32.hpp
@@ -0,0 +1,51 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_UTF32_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_UTF32_HPP
+
+#include <cstddef>
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+#include "read_uint.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename R >
+         struct peek_utf32_impl
+         {
+            using data_t = char32_t;
+            using pair_t = input_pair< char32_t >;
+
+            static_assert( sizeof( char32_t ) == 4, "expected size 4 for 32bit value" );
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.size( 4 ) ) )
+            {
+               if( in.size( 4 ) < 4 ) {
+                  return { 0, 0 };
+               }
+               const char32_t t = R::read( in.current() );
+               if( ( t <= 0x10ffff ) && !( t >= 0xd800 && t <= 0xdfff ) ) {
+                  return { t, 4 };
+               }
+               return { 0, 0 };
+            }
+         };
+
+         using peek_utf32_be = peek_utf32_impl< read_uint32_be >;
+         using peek_utf32_le = peek_utf32_impl< read_uint32_le >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf8.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf8.hpp
new file mode 100644
index 00000000..2c573e85
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/peek_utf8.hpp
@@ -0,0 +1,97 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEEK_UTF8_HPP
+#define TAO_PEGTL_INTERNAL_PEEK_UTF8_HPP
+
+#include "../config.hpp"
+
+#include "input_pair.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct peek_utf8
+         {
+            using data_t = char32_t;
+            using pair_t = input_pair< char32_t >;
+
+            template< typename Input >
+            static pair_t peek( Input& in ) noexcept( noexcept( in.empty() ) )
+            {
+               if( in.empty() ) {
+                  return { 0, 0 };
+               }
+               char32_t c0 = in.peek_uint8();
+               if( ( c0 & 0x80 ) == 0 ) {
+                  return { c0, 1 };
+               }
+               return peek_impl( in, c0 );
+            }
+
+         private:
+            template< typename Input >
+            static pair_t peek_impl( Input& in, char32_t c0 ) noexcept( noexcept( in.size( 4 ) ) )
+            {
+               if( ( c0 & 0xE0 ) == 0xC0 ) {
+                  if( in.size( 2 ) >= 2 ) {
+                     const char32_t c1 = in.peek_uint8( 1 );
+                     if( ( c1 & 0xC0 ) == 0x80 ) {
+                        c0 &= 0x1F;
+                        c0 <<= 6;
+                        c0 |= ( c1 & 0x3F );
+                        if( c0 >= 0x80 ) {
+                           return { c0, 2 };
+                        }
+                     }
+                  }
+               }
+               else if( ( c0 & 0xF0 ) == 0xE0 ) {
+                  if( in.size( 3 ) >= 3 ) {
+                     const char32_t c1 = in.peek_uint8( 1 );
+                     const char32_t c2 = in.peek_uint8( 2 );
+                     if( ( ( c1 & 0xC0 ) == 0x80 ) && ( ( c2 & 0xC0 ) == 0x80 ) ) {
+                        c0 &= 0x0F;
+                        c0 <<= 6;
+                        c0 |= ( c1 & 0x3F );
+                        c0 <<= 6;
+                        c0 |= ( c2 & 0x3F );
+                        if( c0 >= 0x800 && !( c0 >= 0xD800 && c0 <= 0xDFFF ) ) {
+                           return { c0, 3 };
+                        }
+                     }
+                  }
+               }
+               else if( ( c0 & 0xF8 ) == 0xF0 ) {
+                  if( in.size( 4 ) >= 4 ) {
+                     const char32_t c1 = in.peek_uint8( 1 );
+                     const char32_t c2 = in.peek_uint8( 2 );
+                     const char32_t c3 = in.peek_uint8( 3 );
+                     if( ( ( c1 & 0xC0 ) == 0x80 ) && ( ( c2 & 0xC0 ) == 0x80 ) && ( ( c3 & 0xC0 ) == 0x80 ) ) {
+                        c0 &= 0x07;
+                        c0 <<= 6;
+                        c0 |= ( c1 & 0x3F );
+                        c0 <<= 6;
+                        c0 |= ( c2 & 0x3F );
+                        c0 <<= 6;
+                        c0 |= ( c3 & 0x3F );
+                        if( c0 >= 0x10000 && c0 <= 0x10FFFF ) {
+                           return { c0, 4 };
+                        }
+                     }
+                  }
+               }
+               return { 0, 0 };
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pegtl_string.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pegtl_string.hpp
new file mode 100644
index 00000000..f5700afa
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/pegtl_string.hpp
@@ -0,0 +1,103 @@
+// Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PEGTL_STRING_HPP
+#define TAO_PEGTL_INTERNAL_PEGTL_STRING_HPP
+
+#include <cstddef>
+#include <type_traits>
+
+#include "../ascii.hpp"
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      // Inspired by https://github.com/irrequietus/typestring
+      // Rewritten and reduced to what is needed for the PEGTL
+      // and to work with Visual Studio 2015.
+
+      namespace internal
+      {
+         template< typename, typename, typename, typename, typename, typename, typename, typename >
+         struct string_join;
+
+         template< template< char... > class S, char... C0s, char... C1s, char... C2s, char... C3s, char... C4s, char... C5s, char... C6s, char... C7s >
+         struct string_join< S< C0s... >, S< C1s... >, S< C2s... >, S< C3s... >, S< C4s... >, S< C5s... >, S< C6s... >, S< C7s... > >
+         {
+            using type = S< C0s..., C1s..., C2s..., C3s..., C4s..., C5s..., C6s..., C7s... >;
+         };
+
+         template< template< char... > class S, char, bool >
+         struct string_at
+         {
+            using type = S<>;
+         };
+
+         template< template< char... > class S, char C >
+         struct string_at< S, C, true >
+         {
+            using type = S< C >;
+         };
+
+         template< typename T, std::size_t S >
+         struct string_max_length
+         {
+            static_assert( S <= 512, "String longer than 512 (excluding terminating \\0)!" );
+            using type = T;
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#define TAO_PEGTL_INTERNAL_EMPTY()
+#define TAO_PEGTL_INTERNAL_DEFER( X ) X TAO_PEGTL_INTERNAL_EMPTY()
+#define TAO_PEGTL_INTERNAL_EXPAND( ... ) __VA_ARGS__
+
+#define TAO_PEGTL_INTERNAL_STRING_AT( S, x, n ) \
+   tao::TAO_PEGTL_NAMESPACE::internal::string_at< S, ( 0##n < ( sizeof( x ) / sizeof( char ) ) ) ? ( x )[ 0##n ] : 0, ( 0##n < ( sizeof( x ) / sizeof( char ) ) - 1 ) >::type
+
+#define TAO_PEGTL_INTERNAL_JOIN_8( M, S, x, n )                                                  \
+   tao::TAO_PEGTL_NAMESPACE::internal::string_join< TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##0 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##1 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##2 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##3 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##4 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##5 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##6 ), \
+                                                    TAO_PEGTL_INTERNAL_DEFER( M )( S, x, n##7 ) >::type
+
+#define TAO_PEGTL_INTERNAL_STRING_8( S, x, n ) \
+   TAO_PEGTL_INTERNAL_JOIN_8( TAO_PEGTL_INTERNAL_STRING_AT, S, x, n )
+
+#define TAO_PEGTL_INTERNAL_STRING_64( S, x, n ) \
+   TAO_PEGTL_INTERNAL_JOIN_8( TAO_PEGTL_INTERNAL_STRING_8, S, x, n )
+
+#define TAO_PEGTL_INTERNAL_STRING_512( S, x, n ) \
+   TAO_PEGTL_INTERNAL_JOIN_8( TAO_PEGTL_INTERNAL_STRING_64, S, x, n )
+
+#define TAO_PEGTL_INTERNAL_STRING( S, x ) \
+   TAO_PEGTL_INTERNAL_EXPAND(             \
+      TAO_PEGTL_INTERNAL_EXPAND(          \
+         TAO_PEGTL_INTERNAL_EXPAND(       \
+            tao::TAO_PEGTL_NAMESPACE::internal::string_max_length< TAO_PEGTL_INTERNAL_STRING_512( S, x, ), sizeof( x ) - 1 >::type ) ) )
+
+#define TAO_PEGTL_STRING( x ) \
+   TAO_PEGTL_INTERNAL_STRING( tao::TAO_PEGTL_NAMESPACE::ascii::string, x )
+
+#define TAO_PEGTL_ISTRING( x ) \
+   TAO_PEGTL_INTERNAL_STRING( tao::TAO_PEGTL_NAMESPACE::ascii::istring, x )
+
+#define TAO_PEGTL_KEYWORD( x ) \
+   TAO_PEGTL_INTERNAL_STRING( tao::TAO_PEGTL_NAMESPACE::ascii::keyword, x )
+
+// Compatibility, remove with 3.0.0
+#define TAOCPP_PEGTL_STRING( x ) TAO_PEGTL_STRING( x )
+#define TAOCPP_PEGTL_ISTRING( x ) TAO_PEGTL_ISTRING( x )
+#define TAOCPP_PEGTL_KEYWORD( x ) TAO_PEGTL_KEYWORD( x )
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/plus.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/plus.hpp
new file mode 100644
index 00000000..2454ec2c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/plus.hpp
@@ -0,0 +1,68 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_PLUS_HPP
+#define TAO_PEGTL_INTERNAL_PLUS_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "opt.hpp"
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "star.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         // While plus<> could easily be implemented with
+         // seq< Rule, Rules ..., star< Rule, Rules ... > > we
+         // provide an explicit implementation to optimise away
+         // the otherwise created input mark.
+
+         template< typename Rule, typename... Rules >
+         struct plus
+            : plus< seq< Rule, Rules... > >
+         {
+         };
+
+         template< typename Rule >
+         struct plus< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule, opt< plus > >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< A, M, Action, Control >( in, st... ) && Control< star< Rule > >::template match< A, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename Rule, typename... Rules >
+         struct skip_control< plus< Rule, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/raise.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/raise.hpp
new file mode 100644
index 00000000..d4f66430
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/raise.hpp
@@ -0,0 +1,63 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_RAISE_HPP
+#define TAO_PEGTL_INTERNAL_RAISE_HPP
+
+#include <cstdlib>
+#include <stdexcept>
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename T >
+         struct raise
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4702 )
+#endif
+            template< apply_mode,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               Control< T >::raise( static_cast< const Input& >( in ), st... );
+               throw std::logic_error( "code should be unreachable: Control< T >::raise() did not throw an exception" );  // NOLINT, LCOV_EXCL_LINE
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+            }
+         };
+
+         template< typename T >
+         struct skip_control< raise< T > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/range.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/range.hpp
new file mode 100644
index 00000000..650eb799
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/range.hpp
@@ -0,0 +1,58 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_RANGE_HPP
+#define TAO_PEGTL_INTERNAL_RANGE_HPP
+
+#include "../config.hpp"
+
+#include "bump_help.hpp"
+#include "result_on_found.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< result_on_found R, typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi >
+         struct range
+         {
+            static_assert( Lo <= Hi, "invalid range detected" );
+
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< int Eol >
+            struct can_match_eol
+            {
+               static constexpr bool value = ( ( ( Lo <= Eol ) && ( Eol <= Hi ) ) == bool( R ) );
+            };
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Peek::peek( in ) ) )
+            {
+               if( const auto t = Peek::peek( in ) ) {
+                  if( ( ( Lo <= t.data ) && ( t.data <= Hi ) ) == bool( R ) ) {
+                     bump_impl< can_match_eol< Input::eol_t::ch >::value >::bump( in, t.size );
+                     return true;
+                  }
+               }
+               return false;
+            }
+         };
+
+         template< result_on_found R, typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi >
+         struct skip_control< range< R, Peek, Lo, Hi > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/ranges.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/ranges.hpp
new file mode 100644
index 00000000..96217598
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/ranges.hpp
@@ -0,0 +1,100 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_RANGES_HPP
+#define TAO_PEGTL_INTERNAL_RANGES_HPP
+
+#include "../config.hpp"
+
+#include "bump_help.hpp"
+#include "range.hpp"
+#include "skip_control.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< int Eol, typename Char, Char... Cs >
+         struct ranges_impl;
+
+         template< int Eol, typename Char >
+         struct ranges_impl< Eol, Char >
+         {
+            static constexpr bool can_match_eol = false;
+
+            static bool match( const Char /*unused*/ ) noexcept
+            {
+               return false;
+            }
+         };
+
+         template< int Eol, typename Char, Char Eq >
+         struct ranges_impl< Eol, Char, Eq >
+         {
+            static constexpr bool can_match_eol = ( Eq == Eol );
+
+            static bool match( const Char c ) noexcept
+            {
+               return c == Eq;
+            }
+         };
+
+         template< int Eol, typename Char, Char Lo, Char Hi, Char... Cs >
+         struct ranges_impl< Eol, Char, Lo, Hi, Cs... >
+         {
+            static_assert( Lo <= Hi, "invalid range detected" );
+
+            static constexpr bool can_match_eol = ( ( ( Lo <= Eol ) && ( Eol <= Hi ) ) || ranges_impl< Eol, Char, Cs... >::can_match_eol );
+
+            static bool match( const Char c ) noexcept
+            {
+               return ( ( Lo <= c ) && ( c <= Hi ) ) || ranges_impl< Eol, Char, Cs... >::match( c );
+            }
+         };
+
+         template< typename Peek, typename Peek::data_t... Cs >
+         struct ranges
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::any >;
+
+            template< int Eol >
+            struct can_match_eol
+            {
+               static constexpr bool value = ranges_impl< Eol, typename Peek::data_t, Cs... >::can_match_eol;
+            };
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( Peek::peek( in ) ) )
+            {
+               if( const auto t = Peek::peek( in ) ) {
+                  if( ranges_impl< Input::eol_t::ch, typename Peek::data_t, Cs... >::match( t.data ) ) {
+                     bump_impl< can_match_eol< Input::eol_t::ch >::value >::bump( in, t.size );
+                     return true;
+                  }
+               }
+               return false;
+            }
+         };
+
+         template< typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi >
+         struct ranges< Peek, Lo, Hi >
+            : range< result_on_found::success, Peek, Lo, Hi >
+         {
+         };
+
+         template< typename Peek, typename Peek::data_t... Cs >
+         struct skip_control< ranges< Peek, Cs... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/read_uint.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/read_uint.hpp
new file mode 100644
index 00000000..9e975ae5
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/read_uint.hpp
@@ -0,0 +1,85 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_READ_UINT_HPP
+#define TAO_PEGTL_INTERNAL_READ_UINT_HPP
+
+#include <cstdint>
+
+#include "../config.hpp"
+
+#include "endian.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct read_uint16_be
+         {
+            using type = std::uint16_t;
+
+            static std::uint16_t read( const void* d ) noexcept
+            {
+               return be_to_h< std::uint16_t >( d );
+            }
+         };
+
+         struct read_uint16_le
+         {
+            using type = std::uint16_t;
+
+            static std::uint16_t read( const void* d ) noexcept
+            {
+               return le_to_h< std::uint16_t >( d );
+            }
+         };
+
+         struct read_uint32_be
+         {
+            using type = std::uint32_t;
+
+            static std::uint32_t read( const void* d ) noexcept
+            {
+               return be_to_h< std::uint32_t >( d );
+            }
+         };
+
+         struct read_uint32_le
+         {
+            using type = std::uint32_t;
+
+            static std::uint32_t read( const void* d ) noexcept
+            {
+               return le_to_h< std::uint32_t >( d );
+            }
+         };
+
+         struct read_uint64_be
+         {
+            using type = std::uint64_t;
+
+            static std::uint64_t read( const void* d ) noexcept
+            {
+               return be_to_h< std::uint64_t >( d );
+            }
+         };
+
+         struct read_uint64_le
+         {
+            using type = std::uint64_t;
+
+            static std::uint64_t read( const void* d ) noexcept
+            {
+               return le_to_h< std::uint64_t >( d );
+            }
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rematch.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rematch.hpp
new file mode 100644
index 00000000..a43ef893
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rematch.hpp
@@ -0,0 +1,86 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_REMATCH_HPP
+#define TAO_PEGTL_INTERNAL_REMATCH_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../memory_input.hpp"
+#include "../rewind_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Head, typename... Rules >
+         struct rematch;
+
+         template< typename Head >
+         struct rematch< Head >
+         {
+            using analyze_t = typename Head::analyze_t;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Head >::template match< A, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename Head, typename Rule, typename... Rules >
+         struct rematch< Head, Rule, Rules... >
+         {
+            using analyze_t = typename Head::analyze_t;  // NOTE: Rule and Rules are ignored for analyze().
+
+            template< apply_mode A,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< rewind_mode::required >();
+
+               if( Control< Head >::template match< A, rewind_mode::active, Action, Control >( in, st... ) ) {
+                  memory_input< Input::tracking_mode_v, typename Input::eol_t, typename Input::source_t > i2( m.iterator(), in.current(), in.source() );
+#ifdef __cpp_fold_expressions
+                  return m( ( Control< Rule >::template match< A, rewind_mode::active, Action, Control >( i2, st... ) && ... && ( i2.restart( m ), Control< Rules >::template match< A, rewind_mode::active, Action, Control >( i2, st... ) ) ) );
+#else
+                  bool result = Control< Rule >::template match< A, rewind_mode::active, Action, Control >( i2, st... );
+                  using swallow = bool[];
+                  (void)swallow{ result = result && ( i2.restart( m ), Control< Rules >::template match< A, rewind_mode::active, Action, Control >( i2, st... ) )..., true };
+                  return m( result );
+#endif
+               }
+               return false;
+            }
+         };
+
+         template< typename Head, typename... Rules >
+         struct skip_control< rematch< Head, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep.hpp
new file mode 100644
index 00000000..58cddef8
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep.hpp
@@ -0,0 +1,80 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_REP_HPP
+#define TAO_PEGTL_INTERNAL_REP_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< unsigned Num, typename... Rules >
+         struct rep
+            : rep< Num, seq< Rules... > >
+         {
+         };
+
+         template< unsigned Num >
+         struct rep< Num >
+            : trivial< true >
+         {
+         };
+
+         template< typename Rule >
+         struct rep< 0, Rule >
+            : trivial< true >
+         {
+         };
+
+         template< unsigned Num, typename Rule >
+         struct rep< Num, Rule >
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::seq, Num, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+               using m_t = decltype( m );
+
+               for( unsigned i = 0; i != Num; ++i ) {
+                  if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
+                     return false;
+                  }
+               }
+               return m( true );
+            }
+         };
+
+         template< unsigned Num, typename... Rules >
+         struct skip_control< rep< Num, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_min.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_min.hpp
new file mode 100644
index 00000000..869ac119
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_min.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_REP_MIN_HPP
+#define TAO_PEGTL_INTERNAL_REP_MIN_HPP
+
+#include "../config.hpp"
+
+#include "rep.hpp"
+#include "seq.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< unsigned Min, typename Rule, typename... Rules >
+         using rep_min = seq< rep< Min, Rule, Rules... >, star< Rule, Rules... > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_min_max.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_min_max.hpp
new file mode 100644
index 00000000..e584969c
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_min_max.hpp
@@ -0,0 +1,91 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_REP_MIN_MAX_HPP
+#define TAO_PEGTL_INTERNAL_REP_MIN_MAX_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "not_at.hpp"
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< unsigned Min, unsigned Max, typename... Rules >
+         struct rep_min_max
+            : rep_min_max< Min, Max, seq< Rules... > >
+         {
+         };
+
+         template< unsigned Min, unsigned Max >
+         struct rep_min_max< Min, Max >
+            : trivial< false >
+         {
+            static_assert( Min <= Max, "invalid rep_min_max rule (maximum number of repetitions smaller than minimum)" );
+         };
+
+         template< typename Rule >
+         struct rep_min_max< 0, 0, Rule >
+            : not_at< Rule >
+         {
+         };
+
+         template< unsigned Min, unsigned Max, typename Rule >
+         struct rep_min_max< Min, Max, Rule >
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::seq, Min, Rule >;
+
+            static_assert( Min <= Max, "invalid rep_min_max rule (maximum number of repetitions smaller than minimum)" );
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+               using m_t = decltype( m );
+
+               for( unsigned i = 0; i != Min; ++i ) {
+                  if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
+                     return false;
+                  }
+               }
+               for( unsigned i = Min; i != Max; ++i ) {
+                  if( !Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+                     return m( true );
+                  }
+               }
+               return m( Control< not_at< Rule > >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) );  // NOTE that not_at<> will always rewind.
+            }
+         };
+
+         template< unsigned Min, unsigned Max, typename... Rules >
+         struct skip_control< rep_min_max< Min, Max, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_opt.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_opt.hpp
new file mode 100644
index 00000000..59ca8eb4
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rep_opt.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_REP_OPT_HPP
+#define TAO_PEGTL_INTERNAL_REP_OPT_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< unsigned Max, typename... Rules >
+         struct rep_opt
+            : rep_opt< Max, seq< Rules... > >
+         {
+         };
+
+         template< unsigned Max, typename Rule >
+         struct rep_opt< Max, Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
+               }
+               return true;
+            }
+         };
+
+         template< unsigned Max, typename... Rules >
+         struct skip_control< rep_opt< Max, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/require.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/require.hpp
new file mode 100644
index 00000000..043a5b7b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/require.hpp
@@ -0,0 +1,52 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_REQUIRE_HPP
+#define TAO_PEGTL_INTERNAL_REQUIRE_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< unsigned Amount >
+         struct require;
+
+         template<>
+         struct require< 0 >
+            : trivial< true >
+         {
+         };
+
+         template< unsigned Amount >
+         struct require
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( in.size( 0 ) ) )
+            {
+               return in.size( Amount ) >= Amount;
+            }
+         };
+
+         template< unsigned Amount >
+         struct skip_control< require< Amount > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/result_on_found.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/result_on_found.hpp
new file mode 100644
index 00000000..79a19768
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/result_on_found.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_RESULT_ON_FOUND_HPP
+#define TAO_PEGTL_INTERNAL_RESULT_ON_FOUND_HPP
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         enum class result_on_found : bool
+         {
+            success = true,
+            failure = false,
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rules.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rules.hpp
new file mode 100644
index 00000000..fc56a6e8
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/rules.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_RULES_HPP
+#define TAO_PEGTL_INTERNAL_RULES_HPP
+
+#include "action.hpp"
+#include "alnum.hpp"
+#include "alpha.hpp"
+#include "any.hpp"
+#include "apply.hpp"
+#include "apply0.hpp"
+#include "at.hpp"
+#include "bof.hpp"
+#include "bol.hpp"
+#include "bytes.hpp"
+#include "control.hpp"
+#include "disable.hpp"
+#include "discard.hpp"
+#include "enable.hpp"
+#include "eof.hpp"
+#include "eol.hpp"
+#include "eolf.hpp"
+#include "identifier.hpp"
+#include "if_apply.hpp"
+#include "if_must.hpp"
+#include "if_must_else.hpp"
+#include "if_then_else.hpp"
+#include "istring.hpp"
+#include "list.hpp"
+#include "list_must.hpp"
+#include "list_tail.hpp"
+#include "list_tail_pad.hpp"
+#include "must.hpp"
+#include "not_at.hpp"
+#include "one.hpp"
+#include "opt.hpp"
+#include "pad.hpp"
+#include "pad_opt.hpp"
+#include "plus.hpp"
+#include "raise.hpp"
+#include "range.hpp"
+#include "ranges.hpp"
+#include "rematch.hpp"
+#include "rep.hpp"
+#include "rep_min.hpp"
+#include "rep_min_max.hpp"
+#include "rep_opt.hpp"
+#include "require.hpp"
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "sor.hpp"
+#include "star.hpp"
+#include "star_must.hpp"
+#include "state.hpp"
+#include "string.hpp"
+#include "trivial.hpp"
+#include "try_catch_type.hpp"
+#include "until.hpp"
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/seq.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/seq.hpp
new file mode 100644
index 00000000..ab03575a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/seq.hpp
@@ -0,0 +1,91 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_SEQ_HPP
+#define TAO_PEGTL_INTERNAL_SEQ_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct seq;
+
+         template<>
+         struct seq<>
+            : trivial< true >
+         {
+         };
+
+         template< typename Rule >
+         struct seq< Rule >
+         {
+            using analyze_t = typename Rule::analyze_t;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               return Control< Rule >::template match< A, M, Action, Control >( in, st... );
+            }
+         };
+
+         template< typename... Rules >
+         struct seq
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rules... >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+               using m_t = decltype( m );
+#ifdef __cpp_fold_expressions
+               return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
+#else
+               bool result = true;
+               using swallow = bool[];
+               (void)swallow{ result = result && Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... )... };
+               return m( result );
+#endif
+            }
+
+         };  // namespace internal
+
+         template< typename... Rules >
+         struct skip_control< seq< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/skip_control.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/skip_control.hpp
new file mode 100644
index 00000000..2375d4c9
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/skip_control.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_SKIP_CONTROL_HPP
+#define TAO_PEGTL_INTERNAL_SKIP_CONTROL_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         // This class is a simple tagging mechanism.
+         // By default, skip_control< Rule >::value
+         // is 'false'. Each internal (!) rule that should
+         // be hidden from the control and action class'
+         // callbacks simply specializes skip_control<>
+         // to return 'true' for the above expression.
+
+         template< typename Rule >
+         struct skip_control : std::false_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/sor.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/sor.hpp
new file mode 100644
index 00000000..7be085dd
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/sor.hpp
@@ -0,0 +1,76 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_SOR_HPP
+#define TAO_PEGTL_INTERNAL_SOR_HPP
+
+#include "../config.hpp"
+
+#include "integer_sequence.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename... Rules >
+         struct sor;
+
+         template<>
+         struct sor<>
+            : trivial< false >
+         {
+         };
+
+         template< typename... Rules >
+         struct sor
+            : sor< index_sequence_for< Rules... >, Rules... >
+         {
+         };
+
+         template< std::size_t... Indices, typename... Rules >
+         struct sor< index_sequence< Indices... >, Rules... >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::sor, Rules... >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+#ifdef __cpp_fold_expressions
+               return ( Control< Rules >::template match < A, ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required, Action, Control > ( in, st... ) || ... );
+#else
+               bool result = false;
+               using swallow = bool[];
+               (void)swallow{ result = result || Control< Rules >::template match < A, ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required, Action, Control > ( in, st... )... };
+               return result;
+#endif
+            }
+         };
+
+         template< typename... Rules >
+         struct skip_control< sor< Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/star.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/star.hpp
new file mode 100644
index 00000000..d46479f8
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/star.hpp
@@ -0,0 +1,62 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_STAR_HPP
+#define TAO_PEGTL_INTERNAL_STAR_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Rule, typename... Rules >
+         struct star
+            : star< seq< Rule, Rules... > >
+         {};
+
+         template< typename Rule >
+         struct star< Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::opt, Rule, star >;
+
+            template< apply_mode A,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+               }
+               return true;
+            }
+         };
+
+         template< typename Rule, typename... Rules >
+         struct skip_control< star< Rule, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/star_must.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/star_must.hpp
new file mode 100644
index 00000000..84e5a441
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/star_must.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_STAR_MUST_HPP
+#define TAO_PEGTL_INTERNAL_STAR_MUST_HPP
+
+#include "../config.hpp"
+
+#include "if_must.hpp"
+#include "star.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Cond, typename... Rules >
+         using star_must = star< if_must< false, Cond, Rules... > >;
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/state.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/state.hpp
new file mode 100644
index 00000000..891d80b2
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/state.hpp
@@ -0,0 +1,96 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_STATE_HPP
+#define TAO_PEGTL_INTERNAL_STATE_HPP
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename State, typename... Rules >
+         struct state
+            : state< State, seq< Rules... > >
+         {
+         };
+
+         template< typename State, typename Rule >
+         struct state< State, Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static auto success( State& s, const Input& in, States&&... st )
+               -> decltype( s.template success< A, M, Action, Control >( in, st... ), void() )
+            {
+               s.template success< A, M, Action, Control >( in, st... );
+            }
+
+            // NOTE: The additional "int = 0" is a work-around for missing expression SFINAE in VS2015.
+
+            template< apply_mode,
+                      rewind_mode,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States,
+                      int = 0 >
+            static auto success( State& s, const Input& in, States&&... st )
+               -> decltype( s.success( in, st... ), void() )
+            {
+               s.success( in, st... );
+            }
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               State s( static_cast< const Input& >( in ), st... );
+
+               if( Control< Rule >::template match< A, M, Action, Control >( in, s ) ) {
+                  success< A, M, Action, Control >( s, in, st... );
+                  return true;
+               }
+               return false;
+            }
+         };
+
+         template< typename State, typename... Rules >
+         struct skip_control< state< State, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/string.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/string.hpp
new file mode 100644
index 00000000..31903281
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/string.hpp
@@ -0,0 +1,68 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_STRING_HPP
+#define TAO_PEGTL_INTERNAL_STRING_HPP
+
+#include <cstring>
+#include <utility>
+
+#include "../config.hpp"
+
+#include "bump_help.hpp"
+#include "result_on_found.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline bool unsafe_equals( const char* s, const std::initializer_list< char >& l ) noexcept
+         {
+            return std::memcmp( s, &*l.begin(), l.size() ) == 0;
+         }
+
+         template< char... Cs >
+         struct string;
+
+         template<>
+         struct string<>
+            : trivial< true >
+         {
+         };
+
+         template< char... Cs >
+         struct string
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::any, sizeof...( Cs ) >;
+
+            template< typename Input >
+            static bool match( Input& in ) noexcept( noexcept( in.size( 0 ) ) )
+            {
+               if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
+                  if( unsafe_equals( in.current(), { Cs... } ) ) {
+                     bump_help< result_on_found::success, Input, char, Cs... >( in, sizeof...( Cs ) );
+                     return true;
+                  }
+               }
+               return false;
+            }
+         };
+
+         template< char... Cs >
+         struct skip_control< string< Cs... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/trivial.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/trivial.hpp
new file mode 100644
index 00000000..9b764dce
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/trivial.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_TRIVIAL_HPP
+#define TAO_PEGTL_INTERNAL_TRIVIAL_HPP
+
+#include "../config.hpp"
+
+#include "skip_control.hpp"
+
+#include "../analysis/counted.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< bool Result >
+         struct trivial
+         {
+            using analyze_t = analysis::counted< analysis::rule_type::any, unsigned( !Result ) >;
+
+            template< typename Input >
+            static bool match( Input& /*unused*/ ) noexcept
+            {
+               return Result;
+            }
+         };
+
+         template< bool Result >
+         struct skip_control< trivial< Result > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/try_catch_type.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/try_catch_type.hpp
new file mode 100644
index 00000000..3612c198
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/try_catch_type.hpp
@@ -0,0 +1,76 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_TRY_CATCH_TYPE_HPP
+#define TAO_PEGTL_INTERNAL_TRY_CATCH_TYPE_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "trivial.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Exception, typename... Rules >
+         struct try_catch_type
+            : try_catch_type< Exception, seq< Rules... > >
+         {
+         };
+
+         template< typename Exception >
+         struct try_catch_type< Exception >
+            : trivial< true >
+         {
+         };
+
+         template< typename Exception, typename Rule >
+         struct try_catch_type< Exception, Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, Rule >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+               using m_t = decltype( m );
+
+               try {
+                  return m( Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) );
+               }
+               catch( const Exception& ) {
+                  return false;
+               }
+            }
+         };
+
+         template< typename Exception, typename... Rules >
+         struct skip_control< try_catch_type< Exception, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/internal/until.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/until.hpp
new file mode 100644
index 00000000..3e44dc2b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/internal/until.hpp
@@ -0,0 +1,98 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_UNTIL_HPP
+#define TAO_PEGTL_INTERNAL_UNTIL_HPP
+
+#include "../config.hpp"
+
+#include "bytes.hpp"
+#include "eof.hpp"
+#include "not_at.hpp"
+#include "seq.hpp"
+#include "skip_control.hpp"
+#include "star.hpp"
+
+#include "../apply_mode.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../analysis/generic.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< typename Cond, typename... Rules >
+         struct until
+            : until< Cond, seq< Rules... > >
+         {
+         };
+
+         template< typename Cond >
+         struct until< Cond >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, star< not_at< Cond >, not_at< eof >, bytes< 1 > >, Cond >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+
+               while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+                  if( in.empty() ) {
+                     return false;
+                  }
+                  in.bump();
+               }
+               return m( true );
+            }
+         };
+
+         template< typename Cond, typename Rule >
+         struct until< Cond, Rule >
+         {
+            using analyze_t = analysis::generic< analysis::rule_type::seq, star< not_at< Cond >, not_at< eof >, Rule >, Cond >;
+
+            template< apply_mode A,
+                      rewind_mode M,
+                      template< typename... >
+                      class Action,
+                      template< typename... >
+                      class Control,
+                      typename Input,
+                      typename... States >
+            static bool match( Input& in, States&&... st )
+            {
+               auto m = in.template mark< M >();
+               using m_t = decltype( m );
+
+               while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+                  if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
+                     return false;
+                  }
+               }
+               return m( true );
+            }
+         };
+
+         template< typename Cond, typename... Rules >
+         struct skip_control< until< Cond, Rules... > > : std::true_type
+         {
+         };
+
+      }  // namespace internal
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/istream_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/istream_input.hpp
new file mode 100644
index 00000000..4dfe01fb
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/istream_input.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_ISTREAM_INPUT_HPP
+#define TAO_PEGTL_ISTREAM_INPUT_HPP
+
+#include <istream>
+
+#include "buffer_input.hpp"
+#include "config.hpp"
+#include "eol.hpp"
+
+#include "internal/istream_reader.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Eol = eol::lf_crlf, std::size_t Chunk = 64 >
+      struct istream_input
+         : buffer_input< internal::istream_reader, Eol, std::string, Chunk >
+      {
+         template< typename T >
+         istream_input( std::istream& in_stream, const std::size_t in_maximum, T&& in_source )
+            : buffer_input< internal::istream_reader, Eol, std::string, Chunk >( std::forward< T >( in_source ), in_maximum, in_stream )
+         {
+         }
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      istream_input( Ts&&... )->istream_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/match.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/match.hpp
new file mode 100644
index 00000000..802e715e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/match.hpp
@@ -0,0 +1,71 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_MATCH_HPP
+#define TAO_PEGTL_MATCH_HPP
+
+#include <type_traits>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "nothing.hpp"
+#include "require_apply.hpp"
+#include "require_apply0.hpp"
+#include "rewind_mode.hpp"
+
+#include "internal/dusel_mode.hpp"
+#include "internal/duseltronik.hpp"
+#include "internal/has_apply.hpp"
+#include "internal/has_apply0.hpp"
+#include "internal/if_missing.hpp"
+#include "internal/skip_control.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename Input,
+                typename... States >
+      bool match( Input& in, States&&... st )
+      {
+         constexpr bool enable_control = !internal::skip_control< Rule >::value;
+         constexpr bool enable_action = enable_control && ( A == apply_mode::action );
+
+         using iterator_t = typename Input::iterator_t;
+         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const Input&, States... >::value;
+         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const Input&, States... >::value;
+         constexpr bool has_apply = has_apply_void || has_apply_bool;
+
+         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const Input&, States... >::value;
+         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const Input&, States... >::value;
+         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
+
+         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
+
+         constexpr bool is_nothing = std::is_base_of< nothing< Rule >, Action< Rule > >::value;
+         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
+         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
+
+         internal::if_missing< !has_apply && std::is_base_of< require_apply, Action< Rule > >::value >::template apply< Control< Rule >, Action >( in, st... );
+         internal::if_missing< !has_apply0 && std::is_base_of< require_apply0, Action< Rule > >::value >::template apply0< Control< Rule >, Action >( in, st... );
+
+         constexpr bool validate_nothing = std::is_base_of< maybe_nothing, Action< void > >::value;
+         constexpr bool is_maybe_nothing = std::is_base_of< maybe_nothing, Action< Rule > >::value;
+         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
+
+         constexpr auto mode = static_cast< internal::dusel_mode >( enable_control + has_apply_void + 2 * has_apply_bool + 3 * has_apply0_void + 4 * has_apply0_bool );
+         return internal::duseltronik< Rule, A, M, Action, Control, mode >::match( in, st... );
+      }
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/memory_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/memory_input.hpp
new file mode 100644
index 00000000..0ce78909
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/memory_input.hpp
@@ -0,0 +1,378 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_MEMORY_INPUT_HPP
+#define TAO_PEGTL_MEMORY_INPUT_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "normal.hpp"
+#include "nothing.hpp"
+#include "position.hpp"
+#include "tracking_mode.hpp"
+
+#include "internal/action_input.hpp"
+#include "internal/at.hpp"
+#include "internal/bump.hpp"
+#include "internal/eolf.hpp"
+#include "internal/iterator.hpp"
+#include "internal/marker.hpp"
+#include "internal/until.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         template< tracking_mode, typename Eol, typename Source >
+         class memory_input_base;
+
+         template< typename Eol, typename Source >
+         class memory_input_base< tracking_mode::eager, Eol, Source >
+         {
+         public:
+            using iterator_t = internal::iterator;
+
+            template< typename T >
+            memory_input_base( const iterator_t& in_begin, const char* in_end, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+               : m_begin( in_begin.data ),
+                 m_current( in_begin ),
+                 m_end( in_end ),
+                 m_source( std::forward< T >( in_source ) )
+            {
+            }
+
+            template< typename T >
+            memory_input_base( const char* in_begin, const char* in_end, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+               : m_begin( in_begin ),
+                 m_current( in_begin ),
+                 m_end( in_end ),
+                 m_source( std::forward< T >( in_source ) )
+            {
+            }
+
+            memory_input_base( const memory_input_base& ) = delete;
+            memory_input_base( memory_input_base&& ) = delete;
+
+            ~memory_input_base() = default;
+
+            memory_input_base operator=( const memory_input_base& ) = delete;
+            memory_input_base operator=( memory_input_base&& ) = delete;
+
+            const char* current() const noexcept
+            {
+               return m_current.data;
+            }
+
+            const char* begin() const noexcept
+            {
+               return m_begin;
+            }
+
+            const char* end( const std::size_t /*unused*/ = 0 ) const noexcept
+            {
+               return m_end;
+            }
+
+            std::size_t byte() const noexcept
+            {
+               return m_current.byte;
+            }
+
+            std::size_t line() const noexcept
+            {
+               return m_current.line;
+            }
+
+            std::size_t byte_in_line() const noexcept
+            {
+               return m_current.byte_in_line;
+            }
+
+            void bump( const std::size_t in_count = 1 ) noexcept
+            {
+               internal::bump( m_current, in_count, Eol::ch );
+            }
+
+            void bump_in_this_line( const std::size_t in_count = 1 ) noexcept
+            {
+               internal::bump_in_this_line( m_current, in_count );
+            }
+
+            void bump_to_next_line( const std::size_t in_count = 1 ) noexcept
+            {
+               internal::bump_to_next_line( m_current, in_count );
+            }
+
+            TAO_PEGTL_NAMESPACE::position position( const iterator_t& it ) const
+            {
+               return TAO_PEGTL_NAMESPACE::position( it, m_source );
+            }
+
+            void restart( const std::size_t in_byte = 0, const std::size_t in_line = 1, const std::size_t in_byte_in_line = 0 )
+            {
+               m_current.data = m_begin;
+               m_current.byte = in_byte;
+               m_current.line = in_line;
+               m_current.byte_in_line = in_byte_in_line;
+            }
+
+         protected:
+            const char* const m_begin;
+            iterator_t m_current;
+            const char* const m_end;
+            const Source m_source;
+         };
+
+         template< typename Eol, typename Source >
+         class memory_input_base< tracking_mode::lazy, Eol, Source >
+         {
+         public:
+            using iterator_t = const char*;
+
+            template< typename T >
+            memory_input_base( const internal::iterator& in_begin, const char* in_end, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+               : m_begin( in_begin ),
+                 m_current( in_begin.data ),
+                 m_end( in_end ),
+                 m_source( std::forward< T >( in_source ) )
+            {
+            }
+
+            template< typename T >
+            memory_input_base( const char* in_begin, const char* in_end, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+               : m_begin( in_begin ),
+                 m_current( in_begin ),
+                 m_end( in_end ),
+                 m_source( std::forward< T >( in_source ) )
+            {
+            }
+
+            memory_input_base( const memory_input_base& ) = delete;
+            memory_input_base( memory_input_base&& ) = delete;
+
+            ~memory_input_base() = default;
+
+            memory_input_base operator=( const memory_input_base& ) = delete;
+            memory_input_base operator=( memory_input_base&& ) = delete;
+
+            const char* current() const noexcept
+            {
+               return m_current;
+            }
+
+            const char* begin() const noexcept
+            {
+               return m_begin.data;
+            }
+
+            const char* end( const std::size_t /*unused*/ = 0 ) const noexcept
+            {
+               return m_end;
+            }
+
+            std::size_t byte() const noexcept
+            {
+               return std::size_t( current() - m_begin.data );
+            }
+
+            void bump( const std::size_t in_count = 1 ) noexcept
+            {
+               m_current += in_count;
+            }
+
+            void bump_in_this_line( const std::size_t in_count = 1 ) noexcept
+            {
+               m_current += in_count;
+            }
+
+            void bump_to_next_line( const std::size_t in_count = 1 ) noexcept
+            {
+               m_current += in_count;
+            }
+
+            TAO_PEGTL_NAMESPACE::position position( const iterator_t it ) const
+            {
+               internal::iterator c( m_begin );
+               internal::bump( c, std::size_t( it - m_begin.data ), Eol::ch );
+               return TAO_PEGTL_NAMESPACE::position( c, m_source );
+            }
+
+            void restart()
+            {
+               m_current = m_begin.data;
+            }
+
+         protected:
+            const internal::iterator m_begin;
+            iterator_t m_current;
+            const char* const m_end;
+            const Source m_source;
+         };
+
+      }  // namespace internal
+
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf, typename Source = std::string >
+      class memory_input
+         : public internal::memory_input_base< P, Eol, Source >
+      {
+      public:
+         static constexpr tracking_mode tracking_mode_v = P;
+
+         using eol_t = Eol;
+         using source_t = Source;
+
+         using typename internal::memory_input_base< P, Eol, Source >::iterator_t;
+
+         using action_t = internal::action_input< memory_input >;
+
+         using internal::memory_input_base< P, Eol, Source >::memory_input_base;
+
+         template< typename T >
+         memory_input( const char* in_begin, const std::size_t in_size, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+            : memory_input( in_begin, in_begin + in_size, std::forward< T >( in_source ) )
+         {
+         }
+
+         template< typename T >
+         memory_input( const std::string& in_string, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+            : memory_input( in_string.data(), in_string.size(), std::forward< T >( in_source ) )
+         {
+         }
+
+         template< typename T >
+         memory_input( std::string&&, T&& ) = delete;
+
+         template< typename T >
+         memory_input( const char* in_begin, T&& in_source ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+            : memory_input( in_begin, std::strlen( in_begin ), std::forward< T >( in_source ) )
+         {
+         }
+
+         template< typename T >
+         memory_input( const char* in_begin, const char* in_end, T&& in_source, const std::size_t in_byte, const std::size_t in_line, const std::size_t in_byte_in_line ) noexcept( std::is_nothrow_constructible< Source, T&& >::value )
+            : memory_input( { in_begin, in_byte, in_line, in_byte_in_line }, in_end, std::forward< T >( in_source ) )
+         {
+         }
+
+         memory_input( const memory_input& ) = delete;
+         memory_input( memory_input&& ) = delete;
+
+         ~memory_input() = default;
+
+         memory_input operator=( const memory_input& ) = delete;
+         memory_input operator=( memory_input&& ) = delete;
+
+         const Source& source() const noexcept
+         {
+            return this->m_source;
+         }
+
+         bool empty() const noexcept
+         {
+            return this->current() == this->end();
+         }
+
+         std::size_t size( const std::size_t /*unused*/ = 0 ) const noexcept
+         {
+            return std::size_t( this->end() - this->current() );
+         }
+
+         char peek_char( const std::size_t offset = 0 ) const noexcept
+         {
+            return this->current()[ offset ];
+         }
+
+         std::uint8_t peek_uint8( const std::size_t offset = 0 ) const noexcept
+         {
+            return static_cast< std::uint8_t >( peek_char( offset ) );
+         }
+
+         // Compatibility, remove with 3.0.0
+         std::uint8_t peek_byte( const std::size_t offset = 0 ) const noexcept
+         {
+            return static_cast< std::uint8_t >( peek_char( offset ) );
+         }
+
+         iterator_t& iterator() noexcept
+         {
+            return this->m_current;
+         }
+
+         const iterator_t& iterator() const noexcept
+         {
+            return this->m_current;
+         }
+
+         using internal::memory_input_base< P, Eol, Source >::restart;
+
+         template< rewind_mode M >
+         void restart( const internal::marker< iterator_t, M >& m )
+         {
+            iterator() = m.iterator();
+         }
+
+         using internal::memory_input_base< P, Eol, Source >::position;
+
+         TAO_PEGTL_NAMESPACE::position position() const
+         {
+            return position( iterator() );
+         }
+
+         void discard() const noexcept
+         {
+         }
+
+         void require( const std::size_t /*unused*/ ) const noexcept
+         {
+         }
+
+         template< rewind_mode M >
+         internal::marker< iterator_t, M > mark() noexcept
+         {
+            return internal::marker< iterator_t, M >( iterator() );
+         }
+
+         const char* at( const TAO_PEGTL_NAMESPACE::position& p ) const noexcept
+         {
+            return this->begin() + p.byte;
+         }
+
+         const char* begin_of_line( const TAO_PEGTL_NAMESPACE::position& p ) const noexcept
+         {
+            return at( p ) - p.byte_in_line;
+         }
+
+         const char* end_of_line( const TAO_PEGTL_NAMESPACE::position& p ) const noexcept
+         {
+            using input_t = memory_input< tracking_mode::lazy, Eol, const char* >;
+            input_t in( at( p ), this->end(), "" );
+            using grammar = internal::until< internal::at< internal::eolf > >;
+            normal< grammar >::match< apply_mode::nothing, rewind_mode::dontcare, nothing, normal >( in );
+            return in.current();
+         }
+
+         std::string line_at( const TAO_PEGTL_NAMESPACE::position& p ) const
+         {
+            return std::string( begin_of_line( p ), end_of_line( p ) );
+         }
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      memory_input( Ts&&... )->memory_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/mmap_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/mmap_input.hpp
new file mode 100644
index 00000000..f5f2b8c9
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/mmap_input.hpp
@@ -0,0 +1,85 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_MMAP_INPUT_HPP
+#define TAO_PEGTL_MMAP_INPUT_HPP
+
+#include <string>
+#include <utility>
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "memory_input.hpp"
+#include "tracking_mode.hpp"
+
+#if defined( __unix__ ) || ( defined( __APPLE__ ) && defined( __MACH__ ) )
+#include <unistd.h>  // Required for _POSIX_MAPPED_FILES
+#endif
+
+#if defined( _POSIX_MAPPED_FILES )
+#include "internal/file_mapper_posix.hpp"
+#elif defined( _WIN32 )
+#include "internal/file_mapper_win32.hpp"
+#else
+#endif
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct mmap_holder
+         {
+            const std::string filename;
+            const file_mapper data;
+
+            template< typename T >
+            explicit mmap_holder( T&& in_filename )
+               : filename( std::forward< T >( in_filename ) ),
+                 data( filename.c_str() )
+            {
+            }
+
+            mmap_holder( const mmap_holder& ) = delete;
+            mmap_holder( mmap_holder&& ) = delete;
+
+            ~mmap_holder() = default;
+
+            void operator=( const mmap_holder& ) = delete;
+            void operator=( mmap_holder&& ) = delete;
+         };
+
+      }  // namespace internal
+
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
+      struct mmap_input
+         : private internal::mmap_holder,
+           public memory_input< P, Eol, const char* >
+      {
+         template< typename T >
+         explicit mmap_input( T&& in_filename )
+            : internal::mmap_holder( std::forward< T >( in_filename ) ),
+              memory_input< P, Eol, const char* >( data.begin(), data.end(), filename.c_str() )
+         {
+         }
+
+         mmap_input( const mmap_input& ) = delete;
+         mmap_input( mmap_input&& ) = delete;
+
+         ~mmap_input() = default;
+
+         void operator=( const mmap_input& ) = delete;
+         void operator=( mmap_input&& ) = delete;
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      explicit mmap_input( Ts&&... )->mmap_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/normal.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/normal.hpp
new file mode 100644
index 00000000..9db70d46
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/normal.hpp
@@ -0,0 +1,96 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_NORMAL_HPP
+#define TAO_PEGTL_NORMAL_HPP
+
+#include <type_traits>
+#include <utility>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "match.hpp"
+#include "parse_error.hpp"
+#include "rewind_mode.hpp"
+
+#include "internal/demangle.hpp"
+#include "internal/has_match.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Rule >
+      struct normal
+      {
+         template< typename Input, typename... States >
+         static void start( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
+         {
+         }
+
+         template< typename Input, typename... States >
+         static void success( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
+         {
+         }
+
+         template< typename Input, typename... States >
+         static void failure( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
+         {
+         }
+
+         template< typename Input, typename... States >
+         static void raise( const Input& in, States&&... /*unused*/ )
+         {
+            throw parse_error( "parse error matching " + internal::demangle< Rule >(), in );
+         }
+
+         template< template< typename... > class Action, typename Input, typename... States >
+         static auto apply0( const Input& /*unused*/, States&&... st )
+            -> decltype( Action< Rule >::apply0( st... ) )
+         {
+            return Action< Rule >::apply0( st... );
+         }
+
+         template< template< typename... > class Action, typename Iterator, typename Input, typename... States >
+         static auto apply( const Iterator& begin, const Input& in, States&&... st )
+            -> decltype( Action< Rule >::apply( std::declval< typename Input::action_t >(), st... ) )
+         {
+            const typename Input::action_t action_input( begin, in );
+            return Action< Rule >::apply( action_input, st... );
+         }
+
+         template< apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< internal::has_match< void, Rule, A, M, Action, Control, Input, States... >::value, bool >::type
+         {
+            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
+         }
+
+         template< apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class Control,
+                   typename Input,
+                   typename... States,
+                   int = 1 >
+         static auto match( Input& in, States&&... st )
+            -> typename std::enable_if< !internal::has_match< void, Rule, A, M, Action, Control, Input, States... >::value, bool >::type
+         {
+            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
+         }
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/nothing.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/nothing.hpp
new file mode 100644
index 00000000..974afdb6
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/nothing.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_NOTHING_HPP
+#define TAO_PEGTL_NOTHING_HPP
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Rule >
+      struct nothing
+      {
+      };
+
+      using maybe_nothing = nothing< void >;
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/parse.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/parse.hpp
new file mode 100644
index 00000000..d6093e01
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/parse.hpp
@@ -0,0 +1,57 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_PARSE_HPP
+#define TAO_PEGTL_PARSE_HPP
+
+#include <cassert>
+
+#include "apply_mode.hpp"
+#include "config.hpp"
+#include "normal.hpp"
+#include "nothing.hpp"
+#include "parse_error.hpp"
+#include "rewind_mode.hpp"
+
+#include "internal/action_input.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      template< typename Rule,
+                template< typename... > class Action = nothing,
+                template< typename... > class Control = normal,
+                apply_mode A = apply_mode::action,
+                rewind_mode M = rewind_mode::required,
+                typename Input,
+                typename... States >
+      bool parse( Input&& in, States&&... st )
+      {
+         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
+      }
+
+      template< typename Rule,
+                template< typename... > class Action = nothing,
+                template< typename... > class Control = normal,
+                apply_mode A = apply_mode::action,
+                rewind_mode M = rewind_mode::required,
+                typename Outer,
+                typename Input,
+                typename... States >
+      bool parse_nested( const Outer& oi, Input&& in, States&&... st )
+      {
+         try {
+            return parse< Rule, Action, Control, A, M >( in, st... );
+         }
+         catch( parse_error& e ) {
+            e.positions.push_back( oi.position() );
+            throw;
+         }
+      }
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/parse_error.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/parse_error.hpp
new file mode 100644
index 00000000..21ce850e
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/parse_error.hpp
@@ -0,0 +1,51 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_PARSE_ERROR_HPP
+#define TAO_PEGTL_PARSE_ERROR_HPP
+
+#include <stdexcept>
+#include <vector>
+
+#include "config.hpp"
+#include "position.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct parse_error
+         : public std::runtime_error
+      {
+         parse_error( const std::string& msg, std::vector< position >&& in_positions )
+            : std::runtime_error( msg ),
+              positions( std::move( in_positions ) )
+         {
+         }
+
+         template< typename Input >
+         parse_error( const std::string& msg, const Input& in )
+            : parse_error( msg, in.position() )
+         {
+         }
+
+         parse_error( const std::string& msg, const position& pos )
+            : std::runtime_error( to_string( pos ) + ": " + msg ),
+              positions( 1, pos )
+         {
+         }
+
+         parse_error( const std::string& msg, position&& pos )
+            : std::runtime_error( to_string( pos ) + ": " + msg )
+         {
+            positions.emplace_back( std::move( pos ) );
+         }
+
+         std::vector< position > positions;
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/position.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/position.hpp
new file mode 100644
index 00000000..46a982df
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/position.hpp
@@ -0,0 +1,54 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_POSITION_HPP
+#define TAO_PEGTL_POSITION_HPP
+
+#include <cstdlib>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "config.hpp"
+
+#include "internal/iterator.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct position
+      {
+         template< typename T >
+         position( const internal::iterator& in_iter, T&& in_source )
+            : byte( in_iter.byte ),
+              line( in_iter.line ),
+              byte_in_line( in_iter.byte_in_line ),
+              source( std::forward< T >( in_source ) )
+         {
+         }
+
+         std::size_t byte;
+         std::size_t line;
+         std::size_t byte_in_line;
+         std::string source;
+      };
+
+      inline std::ostream& operator<<( std::ostream& o, const position& p )
+      {
+         return o << p.source << ':' << p.line << ':' << p.byte_in_line << '(' << p.byte << ')';
+      }
+
+      inline std::string to_string( const position& p )
+      {
+         std::ostringstream o;
+         o << p;
+         return o.str();
+      }
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/read_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/read_input.hpp
new file mode 100644
index 00000000..9e79358a
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/read_input.hpp
@@ -0,0 +1,80 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_READ_INPUT_HPP
+#define TAO_PEGTL_READ_INPUT_HPP
+
+#include <string>
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "string_input.hpp"
+#include "tracking_mode.hpp"
+
+#include "internal/file_reader.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct filename_holder
+         {
+            const std::string filename;
+
+            template< typename T >
+            explicit filename_holder( T&& in_filename )
+               : filename( std::forward< T >( in_filename ) )
+            {
+            }
+
+            filename_holder( const filename_holder& ) = delete;
+            filename_holder( filename_holder&& ) = delete;
+
+            ~filename_holder() = default;
+
+            void operator=( const filename_holder& ) = delete;
+            void operator=( filename_holder&& ) = delete;
+         };
+
+      }  // namespace internal
+
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
+      struct read_input
+         : private internal::filename_holder,
+           public string_input< P, Eol, const char* >
+      {
+         template< typename T >
+         explicit read_input( T&& in_filename )
+            : internal::filename_holder( std::forward< T >( in_filename ) ),
+              string_input< P, Eol, const char* >( internal::file_reader( filename.c_str() ).read(), filename.c_str() )
+         {
+         }
+
+         template< typename T >
+         read_input( FILE* in_file, T&& in_filename )
+            : internal::filename_holder( std::forward< T >( in_filename ) ),
+              string_input< P, Eol, const char* >( internal::file_reader( in_file, filename.c_str() ).read(), filename.c_str() )
+         {
+         }
+
+         read_input( const read_input& ) = delete;
+         read_input( read_input&& ) = delete;
+
+         ~read_input() = default;
+
+         void operator=( const read_input& ) = delete;
+         void operator=( read_input&& ) = delete;
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      explicit read_input( Ts&&... )->read_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/require_apply.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/require_apply.hpp
new file mode 100644
index 00000000..8e53de56
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/require_apply.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_REQUIRE_APPLY_HPP
+#define TAO_PEGTL_REQUIRE_APPLY_HPP
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct require_apply
+      {};
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/require_apply0.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/require_apply0.hpp
new file mode 100644
index 00000000..e99afbb6
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/require_apply0.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_REQUIRE_APPLY0_HPP
+#define TAO_PEGTL_REQUIRE_APPLY0_HPP
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      struct require_apply0
+      {};
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/rewind_mode.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/rewind_mode.hpp
new file mode 100644
index 00000000..037b9373
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/rewind_mode.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_REWIND_MODE_HPP
+#define TAO_PEGTL_REWIND_MODE_HPP
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      enum class rewind_mode : char
+      {
+         active,
+         required,
+         dontcare,
+
+         // Compatibility, remove with 3.0.0
+         ACTIVE = active,
+         REQUIRED = required,
+         DONTCARE = dontcare
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/rules.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/rules.hpp
new file mode 100644
index 00000000..8f0ce396
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/rules.hpp
@@ -0,0 +1,71 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_RULES_HPP
+#define TAO_PEGTL_RULES_HPP
+
+#include "config.hpp"
+#include "parse_error.hpp"
+
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      // clang-format off
+      template< typename... Actions > struct apply : internal::apply< Actions... > {};
+      template< typename... Actions > struct apply0 : internal::apply0< Actions... > {};
+      template< template< typename... > class Action, typename... Rules > struct action : internal::action< Action, Rules... > {};
+      template< typename... Rules > struct at : internal::at< Rules... > {};
+      struct bof : internal::bof {};
+      struct bol : internal::bol {};
+      template< unsigned Num > struct bytes : internal::bytes< Num > {};
+      template< template< typename... > class Control, typename... Rules > struct control : internal::control< Control, Rules... > {};
+      template< typename... Rules > struct disable : internal::disable< Rules... > {};
+      struct discard : internal::discard {};
+      template< typename... Rules > struct enable : internal::enable< Rules... > {};
+      struct eof : internal::eof {};
+      struct failure : internal::trivial< false > {};
+      template< typename Rule, typename... Actions > struct if_apply : internal::if_apply< Rule, Actions... > {};
+      template< typename Cond, typename... Thens > struct if_must : internal::if_must< false, Cond, Thens... > {};
+      template< typename Cond, typename Then, typename Else > struct if_must_else : internal::if_must_else< Cond, Then, Else > {};
+      template< typename Cond, typename Then, typename Else > struct if_then_else : internal::if_then_else< Cond, Then, Else > {};
+      template< typename Rule, typename Sep, typename Pad = void > struct list : internal::list< Rule, internal::pad< Sep, Pad > > {};
+      template< typename Rule, typename Sep > struct list< Rule, Sep, void > : internal::list< Rule, Sep > {};
+      template< typename Rule, typename Sep, typename Pad = void > struct list_must : internal::list_must< Rule, internal::pad< Sep, Pad > > {};
+      template< typename Rule, typename Sep > struct list_must< Rule, Sep, void > : internal::list_must< Rule, Sep > {};
+      template< typename Rule, typename Sep, typename Pad = void > struct list_tail : internal::list_tail_pad< Rule, Sep, Pad > {};
+      template< typename Rule, typename Sep > struct list_tail< Rule, Sep, void > : internal::list_tail< Rule, Sep > {};
+      template< typename M, typename S > struct minus : internal::rematch< M, internal::not_at< S, internal::eof > > {};
+      template< typename... Rules > struct must : internal::must< Rules... > {};
+      template< typename... Rules > struct not_at : internal::not_at< Rules... > {};
+      template< typename... Rules > struct opt : internal::opt< Rules... > {};
+      template< typename Cond, typename... Rules > struct opt_must : internal::if_must< true, Cond, Rules... > {};
+      template< typename Rule, typename Pad1, typename Pad2 = Pad1 > struct pad : internal::pad< Rule, Pad1, Pad2 > {};
+      template< typename Rule, typename Pad > struct pad_opt : internal::pad_opt< Rule, Pad > {};
+      template< typename Rule, typename... Rules > struct plus : internal::plus< Rule, Rules... > {};
+      template< typename Exception > struct raise : internal::raise< Exception > {};
+      template< typename Head, typename... Rules > struct rematch : internal::rematch< Head, Rules... > {};
+      template< unsigned Num, typename... Rules > struct rep : internal::rep< Num, Rules... > {};
+      template< unsigned Max, typename... Rules > struct rep_max : internal::rep_min_max< 0, Max, Rules... > {};
+      template< unsigned Min, typename Rule, typename... Rules > struct rep_min : internal::rep_min< Min, Rule, Rules... > {};
+      template< unsigned Min, unsigned Max, typename... Rules > struct rep_min_max : internal::rep_min_max< Min, Max, Rules... > {};
+      template< unsigned Max, typename... Rules > struct rep_opt : internal::rep_opt< Max, Rules... > {};
+      template< unsigned Amount > struct require : internal::require< Amount > {};
+      template< typename... Rules > struct seq : internal::seq< Rules... > {};
+      template< typename... Rules > struct sor : internal::sor< Rules... > {};
+      template< typename Rule, typename... Rules > struct star : internal::star< Rule, Rules... > {};
+      template< typename Cond, typename... Rules > struct star_must : internal::star_must< Cond, Rules... > {};
+      template< typename State, typename... Rules > struct state : internal::state< State, Rules... > {};
+      struct success : internal::trivial< true > {};
+      template< typename... Rules > struct try_catch : internal::seq< internal::try_catch_type< parse_error, Rules... > > {};
+      template< typename Exception, typename... Rules > struct try_catch_type : internal::seq< internal::try_catch_type< Exception, Rules... > > {};
+      template< typename Cond, typename... Rules > struct until : internal::until< Cond, Rules... > {};
+      // clang-format on
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/string_input.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/string_input.hpp
new file mode 100644
index 00000000..1c8bd5fe
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/string_input.hpp
@@ -0,0 +1,72 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_STRING_INPUT_HPP
+#define TAO_PEGTL_STRING_INPUT_HPP
+
+#include <string>
+#include <utility>
+
+#include "config.hpp"
+#include "eol.hpp"
+#include "memory_input.hpp"
+#include "tracking_mode.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         struct string_holder
+         {
+            const std::string data;
+
+            template< typename T >
+            explicit string_holder( T&& in_data )
+               : data( std::forward< T >( in_data ) )
+            {
+            }
+
+            string_holder( const string_holder& ) = delete;
+            string_holder( string_holder&& ) = delete;
+
+            ~string_holder() = default;
+
+            void operator=( const string_holder& ) = delete;
+            void operator=( string_holder&& ) = delete;
+         };
+
+      }  // namespace internal
+
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf, typename Source = std::string >
+      struct string_input
+         : private internal::string_holder,
+           public memory_input< P, Eol, Source >
+      {
+         template< typename V, typename T, typename... Ts >
+         explicit string_input( V&& in_data, T&& in_source, Ts&&... ts )
+            : internal::string_holder( std::forward< V >( in_data ) ),
+              memory_input< P, Eol, Source >( data.data(), data.size(), std::forward< T >( in_source ), std::forward< Ts >( ts )... )
+         {
+         }
+
+         string_input( const string_input& ) = delete;
+         string_input( string_input&& ) = delete;
+
+         ~string_input() = default;
+
+         void operator=( const string_input& ) = delete;
+         void operator=( string_input&& ) = delete;
+      };
+
+#ifdef __cpp_deduction_guides
+      template< typename... Ts >
+      explicit string_input( Ts&&... )->string_input<>;
+#endif
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/tracking_mode.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/tracking_mode.hpp
new file mode 100644
index 00000000..9def6bee
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/tracking_mode.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_TRACKING_MODE_HPP
+#define TAO_PEGTL_TRACKING_MODE_HPP
+
+#include "config.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      enum class tracking_mode : bool
+      {
+         eager,
+         lazy,
+
+         // Compatibility, remove with 3.0.0
+         IMMEDIATE = eager,
+         LAZY = lazy
+      };
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/uint16.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/uint16.hpp
new file mode 100644
index 00000000..0080df41
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/uint16.hpp
@@ -0,0 +1,66 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UINT16_HPP
+#define TAO_PEGTL_UINT16_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_mask_uint.hpp"
+#include "internal/peek_uint.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace uint16_be
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint16_be > {};
+
+         template< std::uint16_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint16_be, Cs... > {};
+         template< std::uint16_t Lo, std::uint16_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint16_be, Lo, Hi > {};
+         template< std::uint16_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint16_be, Cs... > {};
+         template< std::uint16_t Lo, std::uint16_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint16_be, Lo, Hi > {};
+         template< std::uint16_t... Cs > struct ranges : internal::ranges< internal::peek_uint16_be, Cs... > {};
+         template< std::uint16_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint16_be, Cs >... > {};
+
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint16_be< M >, Cs... > {};
+         template< std::uint16_t M, std::uint16_t Lo, std::uint16_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint16_be< M >, Lo, Hi > {};
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint16_be< M >, Cs... > {};
+         template< std::uint16_t M, std::uint16_t Lo, std::uint16_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint16_be< M >, Lo, Hi > {};
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint16_be< M >, Cs... > {};
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint16_be< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint16_be
+
+      namespace uint16_le
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint16_le > {};
+
+         template< std::uint16_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint16_le, Cs... > {};
+         template< std::uint16_t Lo, std::uint16_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint16_le, Lo, Hi > {};
+         template< std::uint16_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint16_le, Cs... > {};
+         template< std::uint16_t Lo, std::uint16_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint16_le, Lo, Hi > {};
+         template< std::uint16_t... Cs > struct ranges : internal::ranges< internal::peek_uint16_le, Cs... > {};
+         template< std::uint16_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint16_le, Cs >... > {};
+
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint16_le< M >, Cs... > {};
+         template< std::uint16_t M, std::uint16_t Lo, std::uint16_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint16_le< M >, Lo, Hi > {};
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint16_le< M >, Cs... > {};
+         template< std::uint16_t M, std::uint16_t Lo, std::uint16_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint16_le< M >, Lo, Hi > {};
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint16_le< M >, Cs... > {};
+         template< std::uint16_t M, std::uint16_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint16_le< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint16_le
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/uint32.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/uint32.hpp
new file mode 100644
index 00000000..af54cf32
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/uint32.hpp
@@ -0,0 +1,66 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UINT32_HPP
+#define TAO_PEGTL_UINT32_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_mask_uint.hpp"
+#include "internal/peek_uint.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace uint32_be
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint32_be > {};
+
+         template< std::uint32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint32_be, Cs... > {};
+         template< std::uint32_t Lo, std::uint32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint32_be, Lo, Hi > {};
+         template< std::uint32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint32_be, Cs... > {};
+         template< std::uint32_t Lo, std::uint32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint32_be, Lo, Hi > {};
+         template< std::uint32_t... Cs > struct ranges : internal::ranges< internal::peek_uint32_be, Cs... > {};
+         template< std::uint32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint32_be, Cs >... > {};
+
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint32_be< M >, Cs... > {};
+         template< std::uint32_t M, std::uint32_t Lo, std::uint32_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint32_be< M >, Lo, Hi > {};
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint32_be< M >, Cs... > {};
+         template< std::uint32_t M, std::uint32_t Lo, std::uint32_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint32_be< M >, Lo, Hi > {};
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint32_be< M >, Cs... > {};
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint32_be< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint32_be
+
+      namespace uint32_le
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint32_le > {};
+
+         template< std::uint32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint32_le, Cs... > {};
+         template< std::uint32_t Lo, std::uint32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint32_le, Lo, Hi > {};
+         template< std::uint32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint32_le, Cs... > {};
+         template< std::uint32_t Lo, std::uint32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint32_le, Lo, Hi > {};
+         template< std::uint32_t... Cs > struct ranges : internal::ranges< internal::peek_uint32_le, Cs... > {};
+         template< std::uint32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint32_le, Cs >... > {};
+
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint32_le< M >, Cs... > {};
+         template< std::uint32_t M, std::uint32_t Lo, std::uint32_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint32_le< M >, Lo, Hi > {};
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint32_le< M >, Cs... > {};
+         template< std::uint32_t M, std::uint32_t Lo, std::uint32_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint32_le< M >, Lo, Hi > {};
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint32_le< M >, Cs... > {};
+         template< std::uint32_t M, std::uint32_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint32_le< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint32_le
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/uint64.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/uint64.hpp
new file mode 100644
index 00000000..86074f8b
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/uint64.hpp
@@ -0,0 +1,67 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UINT64_HPP
+#define TAO_PEGTL_UINT64_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_mask_uint.hpp"
+#include "internal/peek_uint.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace uint64_be
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint64_be > {};
+
+         template< std::uint64_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint64_be, Cs... > {};
+         template< std::uint64_t Lo, std::uint64_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint64_be, Lo, Hi > {};
+         template< std::uint64_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint64_be, Cs... > {};
+         template< std::uint64_t Lo, std::uint64_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint64_be, Lo, Hi > {};
+         template< std::uint64_t... Cs > struct ranges : internal::ranges< internal::peek_uint64_be, Cs... > {};
+         template< std::uint64_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint64_be, Cs >... > {};
+
+
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint64_be< M >, Cs... > {};
+         template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint64_be< M >, Lo, Hi > {};
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint64_be< M >, Cs... > {};
+         template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint64_be< M >, Lo, Hi > {};
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint64_be< M >, Cs... > {};
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint64_be< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint64_be
+
+      namespace uint64_le
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint64_le > {};
+
+         template< std::uint64_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint64_le, Cs... > {};
+         template< std::uint64_t Lo, std::uint64_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint64_le, Lo, Hi > {};
+         template< std::uint64_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint64_le, Cs... > {};
+         template< std::uint64_t Lo, std::uint64_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint64_le, Lo, Hi > {};
+         template< std::uint64_t... Cs > struct ranges : internal::ranges< internal::peek_uint64_le, Cs... > {};
+         template< std::uint64_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint64_le, Cs >... > {};
+
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint64_le< M >, Cs... > {};
+         template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint64_le< M >, Lo, Hi > {};
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint64_le< M >, Cs... > {};
+         template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint64_le< M >, Lo, Hi > {};
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint64_le< M >, Cs... > {};
+         template< std::uint64_t M, std::uint64_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint64_le< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint64_le
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/uint8.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/uint8.hpp
new file mode 100644
index 00000000..fe2e11ac
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/uint8.hpp
@@ -0,0 +1,44 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UINT8_HPP
+#define TAO_PEGTL_UINT8_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_mask_uint8.hpp"
+#include "internal/peek_uint8.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace uint8
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_uint8 > {};
+
+         template< std::uint8_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint8, Cs... > {};
+         template< std::uint8_t Lo, std::uint8_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint8, Lo, Hi > {};
+         template< std::uint8_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint8, Cs... > {};
+         template< std::uint8_t Lo, std::uint8_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint8, Lo, Hi > {};
+         template< std::uint8_t... Cs > struct ranges : internal::ranges< internal::peek_uint8, Cs... > {};
+         template< std::uint8_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint8, Cs >... > {};
+
+         template< std::uint8_t M, std::uint8_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint8< M >, Cs... > {};
+         template< std::uint8_t M, std::uint8_t Lo, std::uint8_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint8< M >, Lo, Hi > {};
+         template< std::uint8_t M, std::uint8_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint8< M >, Cs... > {};
+         template< std::uint8_t M, std::uint8_t Lo, std::uint8_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint8< M >, Lo, Hi > {};
+         template< std::uint8_t M, std::uint8_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint8< M >, Cs... > {};
+         template< std::uint8_t M, std::uint8_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint8< M >, Cs >... > {};
+         // clang-format on
+
+      }  // namespace uint8
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/utf16.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/utf16.hpp
new file mode 100644
index 00000000..37f61909
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/utf16.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UTF16_HPP
+#define TAO_PEGTL_UTF16_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_utf16.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace utf16_be
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_utf16_be > {};
+         struct bom : internal::one< internal::result_on_found::success, internal::peek_utf16_be, 0xfeff > {};
+         template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf16_be, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf16_be, Lo, Hi > {};
+         template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf16_be, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf16_be, Lo, Hi > {};
+         template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf16_be, Cs... > {};
+         template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf16_be, Cs >... > {};
+         // clang-format on
+
+      }  // namespace utf16_be
+
+      namespace utf16_le
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_utf16_le > {};
+         struct bom : internal::one< internal::result_on_found::success, internal::peek_utf16_le, 0xfeff > {};
+         template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf16_le, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf16_le, Lo, Hi > {};
+         template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf16_le, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf16_le, Lo, Hi > {};
+         template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf16_le, Cs... > {};
+         template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf16_le, Cs >... > {};
+         // clang-format on
+
+      }  // namespace utf16_le
+
+      namespace utf16 = TAO_PEGTL_NATIVE_UTF16;
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/utf32.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/utf32.hpp
new file mode 100644
index 00000000..e9bafa05
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/utf32.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UTF32_HPP
+#define TAO_PEGTL_UTF32_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_utf32.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace utf32_be
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_utf32_be > {};
+         struct bom : internal::one< internal::result_on_found::success, internal::peek_utf32_be, 0xfeff > {};
+         template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf32_be, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf32_be, Lo, Hi > {};
+         template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf32_be, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf32_be, Lo, Hi > {};
+         template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf32_be, Cs... > {};
+         template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf32_be, Cs >... > {};
+         // clang-format on
+
+      }  // namespace utf32_be
+
+      namespace utf32_le
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_utf32_le > {};
+         struct bom : internal::one< internal::result_on_found::success, internal::peek_utf32_le, 0xfeff > {};
+         template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf32_le, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf32_le, Lo, Hi > {};
+         template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf32_le, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf32_le, Lo, Hi > {};
+         template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf32_le, Cs... > {};
+         template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf32_le, Cs >... > {};
+         // clang-format on
+
+      }  // namespace utf32_le
+
+      namespace utf32 = TAO_PEGTL_NATIVE_UTF32;
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/utf8.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/utf8.hpp
new file mode 100644
index 00000000..4f4befbc
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/utf8.hpp
@@ -0,0 +1,36 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_UTF8_HPP
+#define TAO_PEGTL_UTF8_HPP
+
+#include "config.hpp"
+
+#include "internal/peek_utf8.hpp"
+#include "internal/result_on_found.hpp"
+#include "internal/rules.hpp"
+
+namespace tao
+{
+   namespace TAO_PEGTL_NAMESPACE
+   {
+      namespace utf8
+      {
+         // clang-format off
+         struct any : internal::any< internal::peek_utf8 > {};
+         struct bom : internal::one< internal::result_on_found::success, internal::peek_utf8, 0xfeff > {};
+         template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf8, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf8, Lo, Hi > {};
+         template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf8, Cs... > {};
+         template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf8, Lo, Hi > {};
+         template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf8, Cs... > {};
+         template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf8, Cs >... > {};
+         // clang-format on
+
+      }  // namespace utf8
+
+   }  // namespace TAO_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif
diff --git a/gemmi_gph/gemmi/third_party/tao/pegtl/version.hpp b/gemmi_gph/gemmi/third_party/tao/pegtl/version.hpp
new file mode 100644
index 00000000..4a5e8cf6
--- /dev/null
+++ b/gemmi_gph/gemmi/third_party/tao/pegtl/version.hpp
@@ -0,0 +1,19 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_VERSION_HPP
+#define TAO_PEGTL_VERSION_HPP
+
+#define TAO_PEGTL_VERSION "2.8.3"
+
+#define TAO_PEGTL_VERSION_MAJOR 2
+#define TAO_PEGTL_VERSION_MINOR 8
+#define TAO_PEGTL_VERSION_PATCH 3
+
+// Compatibility, remove with 3.0.0
+#define TAOCPP_PEGTL_VERSION TAO_PEGTL_VERSION
+#define TAOCPP_PEGTL_VERSION_MAJOR TAO_PEGTL_VERSION_MAJOR
+#define TAOCPP_PEGTL_VERSION_MINOR TAO_PEGTL_VERSION_MINOR
+#define TAOCPP_PEGTL_VERSION_PATCH TAO_PEGTL_VERSION_PATCH
+
+#endif
diff --git a/gemmi_gph/json.cpp b/gemmi_gph/json.cpp
new file mode 100644
index 00000000..e1bbdf61
--- /dev/null
+++ b/gemmi_gph/json.cpp
@@ -0,0 +1,132 @@
+// Copyright Global Phasing Ltd.
+
+#include <gemmi/json.hpp>
+#include <utility>  // for move
+
+#define SAJSON_UNSORTED_OBJECT_KEYS
+#define SAJSON_NUMBERS_AS_STRINGS
+// Upstream GEMMI keeps sajson at the root of its repository, outside the include tree; this
+// vendored subset has only the include tree, so it sits beside GEMMI's other bundled third-party
+// headers instead. The only change to this file.
+// https://github.com/project-gemmi/gemmi/blob/v0.7.5/src/json.cpp
+#include "gemmi/third_party/sajson.h"
+
+namespace gemmi {
+namespace cif {
+using std::size_t;
+
+static std::string json_type_as_string(sajson::type t) {
+  switch (t) {
+    case sajson::TYPE_INTEGER: return "<integer>";
+    case sajson::TYPE_DOUBLE:  return "<double>";
+    case sajson::TYPE_NULL:    return "<null>";
+    case sajson::TYPE_FALSE:   return "<false>";
+    case sajson::TYPE_TRUE:    return "<true>";
+    case sajson::TYPE_STRING:  return "<string>";
+    case sajson::TYPE_ARRAY:   return "<array>";
+    case sajson::TYPE_OBJECT:  return "<object>";
+    default:           return "<unknown type>";
+  }
+}
+
+static std::string as_cif_value(const sajson::value& val) {
+  switch (val.get_type()) {
+    case sajson::TYPE_DOUBLE:
+      return val.as_string();
+    case sajson::TYPE_NULL:
+      return "?";
+    // mmJSON files from PDBj (this format has no spec) have special support
+    // for boolean YES|NO, which is used only in category _em_specimen.
+    // IMO it's a bad idea, but we must handle it if we want to read mmJSON.
+    case sajson::TYPE_FALSE:
+      return "NO";  // "." in CIF-JSON
+    case sajson::TYPE_TRUE:
+      return "YES";
+    case sajson::TYPE_STRING:
+      return quote(val.as_string());
+    // Another undocumented feature of mmJSON: arrays as values.
+    // It seems that obscure types int-range and float-range are converted to
+    // 2-element arrays. But not only. link_entity_pdbjplus.db_accession has
+    // arrays with strings.
+    case sajson::TYPE_ARRAY: {
+      std::string s;
+      for (size_t i = 0; i < val.get_length(); ++i) {
+        if (i != 0)
+          s += ' ';
+        s += val.get_array_element(0).as_string();
+      }
+      return quote(s);
+    }
+    default:
+      fail("Unexpected ", json_type_as_string(val.get_type()), " as value in JSON.");
+      return "";
+  }
+}
+
+static void fill_document_from_sajson(Document& d, const sajson::document& s) {
+  // assuming mmJSON here, we'll add handling of CIF-JSON later on
+  sajson::value root = s.get_root();
+  if (root.get_type() != sajson::TYPE_OBJECT)
+    fail("not mmJSON - the root is not of type object");
+  for (size_t block_index = 0; block_index < root.get_length(); ++block_index) {
+    std::string block_name = root.get_object_key(block_index).as_string();
+    if (!starts_with(block_name, "data_"))
+      fail("not mmJSON - top level key should start with data_\n"
+           "(if you use gemmi-cif2json to write JSON, use -m for mmJSON)");
+    d.blocks.emplace_back(block_name.substr(5));
+    std::vector<Item>& items = d.blocks[block_index].items;
+    sajson::value top = root.get_object_value(block_index);
+    if (top.get_type() != sajson::TYPE_OBJECT)
+      fail("");
+    for (size_t i = 0; i != top.get_length(); ++i) {
+      std::string category_name = "_" + top.get_object_key(i).as_string() + ".";
+      sajson::value category = top.get_object_value(i);
+      if (category.get_type() != sajson::TYPE_OBJECT ||
+          category.get_length() == 0 ||
+          category.get_object_value(0).get_type() != sajson::TYPE_ARRAY)
+        fail("");
+      size_t cif_cols = category.get_length();
+      size_t cif_rows = category.get_object_value(0).get_length();
+      if (cif_rows > 1) {
+        items.emplace_back(LoopArg{});
+        Loop& loop = items.back().loop;
+        loop.tags.reserve(cif_cols);
+        loop.values.resize(cif_cols * cif_rows);
+      }
+      for (size_t j = 0; j != cif_cols; ++j) {
+        std::string tag = category_name + category.get_object_key(j).as_string();
+        sajson::value arr = category.get_object_value(j);
+        if (arr.get_type() != sajson::TYPE_ARRAY)
+          fail("Expected array, got " + json_type_as_string(arr.get_type()));
+        if (arr.get_length() != cif_rows)
+          fail("Expected array of length ", std::to_string(cif_rows), " not ",
+               std::to_string(arr.get_length()));
+        if (cif_rows == 1) {
+          items.emplace_back(tag, as_cif_value(arr.get_array_element(0)));
+        } else if (cif_rows != 0) {
+          Loop& loop = items.back().loop;
+          loop.tags.emplace_back(std::move(tag));
+          for (size_t k = 0; k != cif_rows; ++k)
+            loop.values[j + k*cif_cols] = as_cif_value(arr.get_array_element(k));
+        }
+      }
+    }
+  }
+}
+
+Document read_mmjson_insitu(char* buffer, size_t size, const std::string& name) {
+  Document doc;
+  sajson::document json = sajson::parse(sajson::dynamic_allocation(),
+                                    sajson::mutable_string_view(size, buffer));
+  if (!json.is_valid())
+    fail(name + ":", std::to_string(json.get_error_line()), " error: ",
+         json.get_error_message_as_string());
+  fill_document_from_sajson(doc, json);
+  doc.source = name;
+  return doc;
+}
+
+
+
+} // namespace cif
+} // namespace gemmi
diff --git a/gemmi_gph/mmcif.cpp b/gemmi_gph/mmcif.cpp
new file mode 100644
index 00000000..1da0854c
--- /dev/null
+++ b/gemmi_gph/mmcif.cpp
@@ -0,0 +1,1147 @@
+// Copyright 2017-2023 Global Phasing Ltd.
+
+#include <gemmi/mmcif.hpp>   // for string_to_int
+#include <array>
+#include <unordered_map>
+#include <gemmi/mmcif_impl.hpp> // for set_cell_from_mmcif
+#include <gemmi/atox.hpp>    // for string_to_int
+#include <gemmi/enumstr.hpp> // for entity_type_from_string, polymer_type_from_string
+#include <gemmi/numb.hpp>    // for as_number
+#include <gemmi/polyheur.hpp>  // for restore_full_ccd_codes
+
+namespace gemmi {
+
+namespace {
+
+void copy_int(const cif::Table::Row& row, int n, int& dest) {
+  if (row.has2(n))
+    dest = cif::as_int(row[n]);
+}
+void copy_double(const cif::Table::Row& row, int n, double& dest) {
+  if (row.has2(n))
+    dest = cif::as_number(row[n]);
+}
+void copy_string(const cif::Table::Row& row, int n, std::string& dest) {
+  if (row.has2(n))
+    dest = cif::as_string(row[n]);
+}
+
+template<typename T>
+SMat33<T> get_smat33(cif::Table::Row& row, int n) {
+  return SMat33<T>{(T) cif::as_number(row[n+0]),
+                   (T) cif::as_number(row[n+1]),
+                   (T) cif::as_number(row[n+2]),
+                   (T) cif::as_number(row[n+3]),
+                   (T) cif::as_number(row[n+4]),
+                   (T) cif::as_number(row[n+5])};
+}
+
+std::unordered_map<std::string, SMat33<float>> get_anisotropic_u(cif::Block& block) {
+  cif::Table aniso_tab = block.find("_atom_site_anisotrop.",
+                                    {"id", "U[1][1]", "U[2][2]", "U[3][3]",
+                                     "U[1][2]", "U[1][3]", "U[2][3]"});
+  std::unordered_map<std::string, SMat33<float>> aniso_map;
+  for (auto ani : aniso_tab)
+    aniso_map.emplace(ani[0], get_smat33<float>(ani, 1));
+  return aniso_map;
+}
+
+std::vector<std::string> transform_tags(const std::string& mstr, const std::string& vstr) {
+  return {mstr + "[1][1]", mstr + "[1][2]", mstr + "[1][3]", vstr + "[1]",
+          mstr + "[2][1]", mstr + "[2][2]", mstr + "[2][3]", vstr + "[2]",
+          mstr + "[3][1]", mstr + "[3][2]", mstr + "[3][3]", vstr + "[3]"};
+}
+
+Transform get_transform_matrix(const cif::Table::Row& r) {
+  Transform t;
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j)
+      t.mat[i][j] = cif::as_number(r[4*i+j]);
+    t.vec.at(i) = cif::as_number(r[4*i+3]);
+  }
+  return t;
+}
+
+SeqId make_seqid(std::string seqid, const std::string* icode) {
+  SeqId ret;
+  if (icode)
+    // the insertion code happens to be always a single letter
+    ret.icode = cif::as_char(*icode, ' ');
+  if (!seqid.empty()) {
+    // old mmCIF files have auth_seq_id as number + icode (e.g. 15A)
+    if (seqid.back() >= 'A') {
+      if (ret.icode == ' ')
+        ret.icode = seqid.back();
+      else if (ret.icode != seqid.back())
+        fail("Inconsistent insertion code in " + seqid);
+      seqid.pop_back();
+    }
+    // 7pvv has an empty seqnum in tls description, don't throw
+    if (!seqid.empty())
+      ret.num = cif::as_int(seqid, Residue::OptionalNum::None);
+  }
+  return ret;
+}
+
+inline ResidueId make_resid(const std::string& name,
+                            const std::string& seqid,
+                            const std::string* icode) {
+  return ResidueId{make_seqid(seqid, icode), {}, name};
+}
+
+std::vector<Helix> read_helices(cif::Block& block) {
+  std::vector<Helix> helices;
+  for (const auto row : block.find("_struct_conf.", {
+        "conf_type_id",                                          // 0
+        "beg_auth_asym_id", "beg_label_comp_id",                 // 1-2
+        "beg_auth_seq_id", "?pdbx_beg_PDB_ins_code",             // 3-4
+        "end_auth_asym_id", "end_label_comp_id",                 // 5-6
+        "end_auth_seq_id", "?pdbx_end_PDB_ins_code",             // 7-8
+        "?pdbx_PDB_helix_class", "?pdbx_PDB_helix_length"})) {   // 9-10
+    if (alpha_up(row.str(0)[0]) != 'H')
+      continue;
+    Helix h;
+    h.start.chain_name = row.str(1);
+    h.start.res_id = make_resid(row.str(2), row.str(3), row.ptr_at(4));
+    h.end.chain_name = row.str(5);
+    h.end.res_id = make_resid(row.str(6), row.str(7), row.ptr_at(8));
+    if (row.has(9))
+      h.set_helix_class_as_int(cif::as_int(row[9], -1));
+    if (row.has(10))
+      h.length = cif::as_int(row[10], -1);
+    helices.push_back(h);
+  }
+  return helices;
+}
+
+std::vector<Sheet> read_sheets(cif::Block& block) {
+  std::vector<Sheet> sheets;
+  for (const std::string& sheet_id : block.find_values("_struct_sheet.id"))
+    sheets.emplace_back(sheet_id);
+  for (const auto row : block.find("_struct_sheet_range.", {
+        "sheet_id", "id",                                        // 0-1
+        "beg_auth_asym_id", "beg_label_comp_id",                 // 2-3
+        "beg_auth_seq_id", "?pdbx_beg_PDB_ins_code",             // 4-5
+        "end_auth_asym_id", "end_label_comp_id",                 // 6-7
+        "end_auth_seq_id", "?pdbx_end_PDB_ins_code"})) {         // 8-9
+    Sheet& sheet = impl::find_or_add(sheets, row.str(0));
+    sheet.strands.emplace_back();
+    Sheet::Strand& strand = sheet.strands.back();
+    strand.name = row.str(1);
+    strand.start.chain_name = row.str(2);
+    strand.start.res_id = make_resid(row.str(3), row.str(4), row.ptr_at(5));
+    strand.end.chain_name = row.str(6);
+    strand.end.res_id = make_resid(row.str(7), row.str(8), row.ptr_at(9));
+  }
+
+  // below we assume that range_id_1 is the strand preceding range_id_2
+  for (const auto row : block.find("_struct_sheet_order.", {
+        "sheet_id", "range_id_2", "sense"}))
+    if (Sheet* sheet = impl::find_or_null(sheets, row.str(0)))
+      if (Sheet::Strand* ss = impl::find_or_null(sheet->strands, row.str(1)))
+        switch (alpha_up(row.str(2)[0])) {
+          case 'P': ss->sense = 1; break; // parallel
+          case 'A': ss->sense = -1; break; // anti-parallel
+        }
+
+  for (const auto row : block.find("_pdbx_struct_sheet_hbond.", {
+        "sheet_id", "range_id_2",
+        "range_1_auth_asym_id", "range_1_label_comp_id",
+        "range_1_auth_seq_id", "?range_1_PDB_ins_code",
+        "range_1_label_atom_id",
+        "range_2_auth_asym_id", "range_2_label_comp_id",
+        "range_2_auth_seq_id", "?range_2_PDB_ins_code",
+        "range_2_label_atom_id"}))
+    if (Sheet* sheet = impl::find_or_null(sheets, row.str(0)))
+      if (Sheet::Strand* ss = impl::find_or_null(sheet->strands, row.str(1))) {
+        ss->hbond_atom1.chain_name = row.str(2);
+        ss->hbond_atom1.res_id = make_resid(row.str(3), row.str(4),
+                                            row.ptr_at(5));
+        ss->hbond_atom1.atom_name = row.str(6);
+        ss->hbond_atom2.chain_name = row.str(7);
+        ss->hbond_atom2.res_id = make_resid(row.str(8), row.str(9),
+                                            row.ptr_at(10));
+        ss->hbond_atom2.atom_name = row.str(11);
+      }
+
+  return sheets;
+}
+
+void set_part_of_address_from_label(AtomAddress& a, const Model& model,
+                                    const std::string& label_asym,
+                                    const std::string& label_seq_id_raw) {
+  int seq = cif::as_int(label_seq_id_raw, SeqId::OptionalNum::None);
+  for (const Chain& chain : model.chains)
+    if (ConstResidueSpan sub = chain.get_subchain(label_asym)) {
+      a.chain_name = chain.name;
+      for (const Residue& res : sub)
+        if (res.label_seq == seq) {
+          a.res_id.seqid = res.seqid;
+          return;
+        }
+    }
+}
+
+void read_connectivity(cif::Block& block, Structure& st) {
+  enum {
+    kId=0, kConnTypeId=1,
+    kAuthAsymId=2/*-3*/,  kLabelAsymId=4/*-5*/, kLabelCompId=6/*-7*/,
+    kLabelAtomId=8/*-9*/, kLabelAltId=10/*-11*/,
+    kAuthSeqId=12/*-13*/, kLabelSeqId=14/*-15*/, kInsCode=16/*-17*/,
+    kSym1=18, kSym2=19, kDistValue=20, kLinkId=21
+  };
+  // label_ identifiers are not sufficient for HOH:
+  // waters have null label_seq_id so we need auth_seq_id+icode.
+  // And since we need auth_seq_id, we also use auth_asym_id for consistency.
+  // Unless only label_*_id are available.
+  for (const auto row : block.find("_struct_conn.", {
+        "id", "conn_type_id",                                   // 0-1
+        "?ptnr1_auth_asym_id", "?ptnr2_auth_asym_id",           // 2-3
+        "?ptnr1_label_asym_id", "?ptnr2_label_asym_id",         // 4-5
+        "ptnr1_label_comp_id", "ptnr2_label_comp_id",           // 6-7
+        "ptnr1_label_atom_id", "ptnr2_label_atom_id",           // 8-9
+        "?pdbx_ptnr1_label_alt_id", "?pdbx_ptnr2_label_alt_id", // 10-11
+        "?ptnr1_auth_seq_id", "?ptnr2_auth_seq_id",             // 12-13
+        "?ptnr1_label_seq_id", "?ptnr2_label_seq_id",           // 14-15
+        "?pdbx_ptnr1_PDB_ins_code", "?pdbx_ptnr2_PDB_ins_code", // 16-17
+        "?ptnr1_symmetry", "?ptnr2_symmetry",                   // 18-19
+        "?pdbx_dist_value", "?ccp4_link_id"})) {                // 20-21
+    Connection c;
+    c.name = row.str(kId);
+    copy_string(row, kLinkId, c.link_id);
+    c.type = connection_type_from_string(row.str(kConnTypeId));
+    if (row.has2(kSym1) && row.has2(kSym2)) {
+      std::string s1 = row.str(kSym1);
+      std::string s2 = row.str(kSym2);
+      if (s1 == s2) {
+        c.asu = Asu::Same;
+      } else {
+        c.asu = Asu::Different;
+        size_t sep1 = s2.find('_');
+        size_t sep2 = s2.find('_');
+        if (sep1 != std::string::npos && sep1 + 4 == s1.size() &&
+            sep2 != std::string::npos && sep2 + 4 == s2.size()) {
+          if (s1[0] == '1' && s1[1] == '_')  // symop1 is usually 1_555
+            c.reported_sym[0] = no_sign_atoi(s2.c_str());
+          else
+            c.reported_sym[0] = 99;
+          for (size_t i = 1; i <= 3; ++i)
+            c.reported_sym[i] = s2[sep2 + i] - s1[sep1 + i];
+        }
+      }
+    }
+    copy_double(row, kDistValue, c.reported_distance);
+    for (int i = 0; i < 2; ++i) {
+      AtomAddress& a = (i == 0 ? c.partner1 : c.partner2);
+      if (row.has(kAuthAsymId+i) && row.has(kAuthSeqId+i)) {
+        a.chain_name = row.str(kAuthAsymId+i);
+        a.res_id = make_resid(row.str(kLabelCompId+i),
+                              row.str(kAuthSeqId+i), row.ptr_at(kInsCode+i));
+      } else if (row.has(kLabelAsymId+i) && row.has(kLabelSeqId+i)) {
+        set_part_of_address_from_label(a, st.first_model(),
+                                       row.str(kLabelAsymId+i),
+                                       row[kLabelSeqId+i]);
+        a.res_id.name = row.str(kLabelCompId+i);
+      } else {
+        fail("_struct_conn without either _auth_ or _label_ asym_id+seq_id");
+      }
+      a.atom_name = row.str(kLabelAtomId+i);
+      if (row.has2(kLabelAltId+i))
+        a.altloc = cif::as_char(row[kLabelAltId+i], '\0');
+    }
+    st.connections.emplace_back(c);
+  }
+}
+
+// CISPEP equivalent
+void read_prot_cis(cif::Block& block, Structure& st) {
+  enum {
+    kModelNum=0,
+    kAuthAsymId=1, kAuthSeqId=2, kInsCode=3, kLabelCompId=4, kAuthCompId=5,
+    kAuthAsymId2=6, kAuthSeqId2=7, kInsCode2=8, kLabelCompId2=9, kAuthCompId2=10,
+    kAltId=11, kOmegaAngle=12
+  };
+  // We could use label_seq_id etc and call set_part_of_address_from_label(),
+  // but for now let's assume that auth_seq_id etc are there.
+  for (auto row : block.find("_struct_mon_prot_cis.",
+                             {"pdbx_PDB_model_num",                  // 0
+                              "auth_asym_id",                        // 1
+                              "auth_seq_id", "?pdbx_PDB_ins_code",   // 2-3
+                              "?label_comp_id", "?auth_comp_id",     // 4-5
+                              "?pdbx_auth_asym_id_2",                // 6
+                              "?pdbx_auth_seq_id_2", "?pdbx_PDB_ins_code_2",   // 7-8
+                              "?pdbx_label_comp_id_2", "?pdbx_auth_comp_id_2", // 9-10
+                              "?label_alt_id", "?pdbx_omega_angle"})) {        // 11-12
+    CisPep cispep;
+    cispep.model_num = cif::as_int(row[kModelNum], 0);
+    cispep.partner_c.chain_name = row.str(kAuthAsymId);
+    cispep.partner_c.res_id.seqid = make_seqid(row.str(kAuthSeqId), row.ptr_at(kInsCode));
+    cispep.partner_c.res_id.name = cif::as_string(row.one_of(kAuthCompId, kLabelCompId));
+    if (row.has(kAuthAsymId2))
+      cispep.partner_n.chain_name = row.str(kAuthAsymId2);
+    if (row.has(kAuthSeqId2))
+      cispep.partner_n.res_id.seqid = make_seqid(row.str(kAuthSeqId2), row.ptr_at(kInsCode2));
+    cispep.partner_n.res_id.name = cif::as_string(row.one_of(kAuthCompId2, kLabelCompId2));
+    if (row.has(kAltId))
+      cispep.only_altloc = cif::as_char(row[kAltId], '\0');
+    if (row.has(kOmegaAngle))
+      cispep.reported_angle = cif::as_number(row[kOmegaAngle]);
+    st.cispeps.push_back(cispep);
+  }
+}
+
+// MODRES equivalent
+void read_struct_mod_residue(cif::Block& block, Structure& st) {
+  // Here auth_asym_id etc are mandatory and label_asym_id etc optional.
+  for (auto row : block.find("_pdbx_struct_mod_residue.",
+                             {"auth_asym_id",  // 0
+                              "auth_seq_id", "?PDB_ins_code",  // 1-2
+                              "?auth_comp_id", "?label_comp_id",  // 3-4
+                              "?parent_comp_id", "?details",  // 5-6
+                              "?ccp4_mod_id"})) {  // 7
+    ModRes modres;
+    modres.chain_name = row.str(0);
+    modres.res_id.seqid = make_seqid(row.str(1), row.ptr_at(2));
+    modres.res_id.name = row.one_of(3, 4);
+    if (row.has(5))
+      modres.parent_comp_id = row.str(5);
+    if (row.has(6))
+      modres.details = row.str(6);
+    if (row.has(7))
+      modres.mod_id = row.str(7);
+    st.mod_residues.push_back(modres);
+  }
+}
+
+// Operation expression is an item type used for *.oper_expression.
+// Here, to keep it simple, we ignore products such as "(2)(3)".
+// We parse "3", "1,3,5", "one,two", "(3)", "(a)", "(1-60)", "(2,3-8,XY)", etc
+std::vector<std::string> parse_operation_expr(const std::string& expr) {
+  std::vector<std::string> result;
+  std::size_t start = 0;
+  std::size_t close_br = std::string::npos;
+  if (expr[0] == '(') {
+    start = 1;
+    close_br = expr.find(')');
+  }
+  for (;;) {
+    std::size_t sep = std::min(expr.find(',', start), close_br);
+    std::size_t minus = expr.find('-', start);
+    if (minus < sep) {
+      int n_min = no_sign_atoi(expr.c_str() + start);
+      int n_max = no_sign_atoi(expr.c_str() + minus + 1);
+      for (int n = n_min; n <= n_max; ++n)
+        result.push_back(std::to_string(n));
+    } else {
+      result.emplace_back(expr, start, sep - start);
+    }
+    if (sep == close_br)
+      break;
+    start = sep + 1;
+  }
+  return result;
+}
+
+std::vector<Assembly> read_assemblies(cif::Block& block) {
+  std::vector<Assembly> assemblies;
+  cif::Table prop_tab = block.find("_pdbx_struct_assembly_prop.",
+                                   {"biol_id", "type", "value"});
+  cif::Table gen_tab = block.find("_pdbx_struct_assembly_gen.",
+                          {"assembly_id", "oper_expression", "asym_id_list"});
+  std::vector<Assembly::Operator> oper_list;
+  std::vector<std::string> oper_list_tags = transform_tags("matrix", "vector");
+  oper_list_tags.emplace_back("id");  // 12
+  oper_list_tags.emplace_back("type");  // 13
+  for (const auto row : block.find("_pdbx_struct_oper_list.", oper_list_tags)) {
+    oper_list.emplace_back();
+    oper_list.back().name = row.str(12);
+    oper_list.back().type = row.str(13);
+    oper_list.back().transform = get_transform_matrix(row);
+  }
+  for (const auto row : block.find("_pdbx_struct_assembly.", {
+        "id", "details", "method_details",
+        "oligomeric_details", "oligomeric_count"})) {
+    assemblies.emplace_back(row.str(0));
+    Assembly& a = assemblies.back();
+    std::string detail = row.str(1);
+    if (detail == "author_and_software_defined_assembly")
+      a.author_determined = a.software_determined = true;
+    else if (detail == "author_defined_assembly")
+      a.author_determined = true;
+    else if (detail == "software_defined_assembly")
+      a.software_determined = true;
+    else if (detail == "complete icosahedral assembly")
+      a.special_kind = Assembly::SpecialKind::CompleteIcosahedral;
+    else if (detail == "representative helical assembly")
+      a.special_kind = Assembly::SpecialKind::RepresentativeHelical;
+    else if (detail == "complete point assembly")
+      a.special_kind = Assembly::SpecialKind::CompletePoint;
+
+    if (!a.author_determined && !a.software_determined &&
+        a.special_kind == Assembly::SpecialKind::NA && !detail.empty()) {
+      assemblies.pop_back();
+      continue;
+    }
+    if (a.software_determined && !cif::is_null(row[2]))
+      a.software_name = row.str(2);  // method_details
+    a.oligomeric_details = row.str(3);
+    a.oligomeric_count = cif::as_int(row[4], 0);
+    for (const auto row_p : prop_tab)
+      if (row_p.str(0) == a.name) {
+        std::string type = row_p.str(1);
+        double value = cif::as_number(row_p[2]);
+        if (type == "ABSA (A^2)")
+          a.absa = value;
+        else if (type == "SSA (A^2)")
+          a.ssa = value;
+        else if (type == "MORE")
+          a.more = value;
+      }
+    for (const auto row_g : gen_tab)
+      if (row_g.str(0) == a.name) {
+        a.generators.emplace_back();
+        Assembly::Gen& gen = a.generators.back();
+        split_str_into(row_g.str(2), ',', gen.subchains);
+        for (const std::string& name : parse_operation_expr(row_g.str(1)))
+          if (const Assembly::Operator* oper = impl::find_or_null(oper_list, name))
+            gen.operators.push_back(*oper);
+      }
+  }
+  return assemblies;
+}
+
+void fill_residue_entity_type(Structure& st) {
+  for (Model& model : st.models)
+    for (Chain& chain : model.chains)
+      for (ResidueSpan& sub : chain.subchains()) {
+        if (const Entity* ent = st.get_entity_of(sub)) {
+          for (Residue& res : sub)
+            res.entity_type = ent->entity_type;
+        } else {
+          // Don't attempt to distinguish Polymer, Branched and NonPolymer here.
+          // Third-party software may not use the same conventions regarding
+          // label_seq_id and label_asym_id that the PDB uses.
+          for (Residue& res : sub)
+            res.entity_type = res.is_water() ? EntityType::Water : EntityType::Unknown;
+        }
+      }
+}
+
+void read_sifts_unp(cif::Block& block, Structure& st) {
+  enum { kEntityId=0, kAsymId, kSeqIdOrdinal, kSeqId, kObserved,
+         kUnpRes, kUnpNum, kUnpAcc };
+  cif::Table table = block.find("_pdbx_sifts_xref_db.", {
+      "entity_id", "asym_id", "seq_id_ordinal", "seq_id", "observed",
+      "unp_res", "unp_num", "unp_acc"});
+  if (!table.ok())
+    return;
+  for (Model& model : st.models) {
+    Entity* ent = nullptr;
+    ResidueSpan polymer;
+    Residue* res = nullptr;
+    std::string unp_acc;
+    SiftsUnpResidue unp;
+    for (const auto row : table) {
+      if (row[kSeqIdOrdinal] != "1" || row[kObserved][0] != 'y')
+        continue;
+      if (cif::is_null(row[kUnpAcc]) || cif::is_null(row[kUnpNum]))
+        continue;
+      bool update_acc_index = false;
+      if (!ent || row[kEntityId] != ent->name) {
+        ent = st.get_entity(row[kEntityId]);
+        if (!ent)
+          fail("_pdbx_sifts_xref_db: entity_id not found: " + row[kEntityId]);
+        update_acc_index = true;
+      }
+      if (row[kUnpAcc] != unp_acc) {
+        unp_acc = row.str(kUnpAcc);
+        update_acc_index = true;
+      }
+      if (update_acc_index) {
+        auto& vec = ent->sifts_unp_acc;
+        auto it = std::find(vec.begin(), vec.end(), unp_acc);
+        unp.acc_index = std::uint8_t(it - vec.begin());
+        if (it == vec.end())
+          vec.push_back(unp_acc);
+      }
+      if (!polymer || row[kAsymId] != polymer.front().subchain) {
+        polymer = model.get_subchain(row[kAsymId]);
+        if (!polymer)
+          fail("_pdbx_sifts_xref_db: asym_id not found: " + row[kAsymId]);
+        res = polymer.begin();
+      } else if (res == polymer.end()) {
+        res = polymer.begin();
+      }
+      int label_seq = cif::as_int(row[kSeqId]);
+      if (res->label_seq != label_seq) {
+        res = polymer.begin();
+        while (res->label_seq != label_seq) {
+          ++res;
+          if (res == polymer.end())
+            fail("_pdbx_sifts_xref_db: seq_id not found: " + row[kSeqId]);
+        }
+      }
+      unp.res = cif::as_char(row[kUnpRes], '\0');
+      int num = cif::as_int(row[kUnpNum]);
+      unp.num = (std::uint16_t) num;
+      if (num != (int)unp.num)
+        fail("_pdbx_sifts_xref_db.unp_num: " + row[kUnpNum]);
+      while (res->label_seq == label_seq && res != polymer.end()) {
+        res->sifts_unp = unp;
+        ++res;
+      }
+    }
+  }
+}
+
+DiffractionInfo* find_diffrn(Metadata& meta, const std::string& diffrn_id) {
+  for (CrystalInfo& crystal_info : meta.crystals)
+    for (DiffractionInfo& diffr_info : crystal_info.diffractions)
+      if (diffr_info.id == diffrn_id)
+        return &diffr_info;
+  return nullptr;
+}
+
+// optimized Row::one_of(), use with care or it will crash a program
+struct RowAccess {
+  const std::string *val = nullptr;
+  const std::string *fallback = nullptr;
+  RowAccess(const cif::Table& tab, int n1, int n2) {
+    int pos1 = tab.positions.at(n1);
+    int pos2 = tab.positions.at(n2);
+    if (pos1 < 0) {
+      pos1 = pos2;
+      pos2 = -1;
+    }
+    const cif::Loop* loop = const_cast<cif::Table&>(tab).get_loop();
+    if (pos1 >= 0)
+      val = loop ? &loop->values[pos1] : &tab.bloc.items[pos1].pair[1];
+    if (pos2 >= 0)
+      fallback = loop ? &loop->values[pos2] : &tab.bloc.items[pos2].pair[1];
+  }
+  bool ok() const { return val != nullptr; }
+  const std::string& get(size_t gap) const {
+    const std::string& r = val[gap];
+    if (!cif::is_null(r) || fallback == nullptr)
+      return r;
+    return fallback[gap];
+  }
+};
+
+template<class T>
+T* get_by_id(std::vector<T>& vec, const std::string& id) {
+  for (T& item : vec)
+    if (item.id == id)
+      return &item;
+  return nullptr;
+}
+
+void read_entry_info(cif::Block& block, gemmi::Structure& st) {
+    auto add_info = [&](const std::string& tag) {
+        bool first = true;
+        for (const std::string& v : block.find_values(tag))
+            if (!cif::is_null(v)) {
+                if (first)
+                    st.info[tag] = cif::as_string(v);
+                else
+                    st.info[tag] += "; " + cif::as_string(v);
+                first = false;
+            }
+    };
+    add_info("_entry.id");
+    add_info("_cell.Z_PDB");
+    add_info("_exptl.method");
+    add_info("_struct.title");
+    // in pdbx/mmcif v5 date_original was replaced with a much longer tag
+    std::string old_date_tag = "_database_PDB_rev.date_original";
+    std::string new_date_tag = "_pdbx_database_status.recvd_initial_deposition_date";
+    add_info(old_date_tag);
+    add_info(new_date_tag);
+    if (st.info.count(old_date_tag) == 1 && st.info.count(new_date_tag) == 0)
+        st.info[new_date_tag] = st.info[old_date_tag];
+    add_info("_struct_keywords.pdbx_keywords");
+    add_info("_struct_keywords.text");
+}
+
+void read_audit_author(cif::Block& block, Structure& st) {
+    for (const std::string& v : block.find_values("_audit_author.name"))
+        if (!cif::is_null(v))
+            st.meta.authors.push_back(cif::as_string(v));
+}
+
+void read_refinement_info(cif::Block& block, Structure& st) {
+    for (auto row : block.find("_refine.", {"pdbx_refine_id",           // 0
+                                            "?ls_d_res_high",           // 1
+                                            "?ls_d_res_low",            // 2
+                                            "?ls_percent_reflns_obs",   // 3
+                                            "?ls_number_reflns_obs",    // 4
+                                            "?ls_number_reflns_R_work", // 5
+                                            "?ls_number_reflns_R_free", // 6
+                                            "?ls_R_factor_obs",         // 7
+                                            "?ls_R_factor_R_work",      // 8
+                                            "?ls_R_factor_R_free"})) {
+        st.meta.refinement.emplace_back();
+        RefinementInfo& ref = st.meta.refinement.back();
+        ref.id = row.str(0);
+        if (row.has(1)) {
+            ref.resolution_high = cif::as_number(row[1]);
+            if (ref.resolution_high > 0 &&
+                (st.resolution == 0 || ref.resolution_high < st.resolution))
+                st.resolution = ref.resolution_high;
+        }
+        copy_double(row, 2, ref.resolution_low);
+        copy_double(row, 3, ref.completeness);
+        copy_int(row, 4, ref.reflection_count);
+        copy_int(row, 5, ref.work_set_count);
+        copy_int(row, 6, ref.rfree_set_count);
+        copy_double(row, 7, ref.r_all);
+        copy_double(row, 8, ref.r_work);
+        copy_double(row, 9, ref.r_free);
+    }
+    if (st.resolution == 0.) {
+      const std::string* em_res = block.find_value("_em_3d_reconstruction.resolution");
+      if (em_res)
+        st.resolution = cif::as_number(*em_res);
+
+    }
+}
+
+void read_tls_info(cif::Block& block, Structure& st) {
+    for (auto row : block.find("_pdbx_refine_tls.", {
+        "id", "?pdbx_refine_id",
+        "T[1][1]", "T[2][2]", "T[3][3]", "T[1][2]", "T[1][3]", "T[2][3]",
+        "L[1][1]", "L[2][2]", "L[3][3]", "L[1][2]", "L[1][3]", "L[2][3]",
+        "S[1][1]", "S[1][2]", "S[1][3]",
+        "S[2][1]", "S[2][2]", "S[2][3]",
+        "S[3][1]", "S[3][2]", "S[3][3]",
+        "origin_x", "origin_y", "origin_z"})) {
+        if (st.meta.refinement.empty())
+            break;
+        RefinementInfo* ref = nullptr;
+        if (row.has(1))
+            ref = get_by_id(st.meta.refinement, row.str(1));
+        if (!ref)
+            ref = &st.meta.refinement[0];
+        ref->tls_groups.emplace_back();
+        TlsGroup& tls = ref->tls_groups.back();
+        tls.id = row.str(0);
+        tls.num_id = (short) no_sign_atoi(tls.id.c_str());
+        tls.T = get_smat33<double>(row, 2);
+        tls.L = get_smat33<double>(row, 8);
+        for (int i = 0; i < 3; ++i)
+            for (int j = 0; j < 3; ++j)
+                tls.S[i][j] = cif::as_number(row[14+3*i+j]);
+        tls.origin.x = cif::as_number(row[23]);
+        tls.origin.y = cif::as_number(row[24]);
+        tls.origin.z = cif::as_number(row[25]);
+    }
+    for (auto row : block.find("_pdbx_refine_tls_group.", {
+        "refine_tls_id", "?beg_auth_asym_id", "?beg_auth_seq_id", "?beg_PDB_ins_code",
+        "?end_auth_seq_id", "?end_PDB_ins_code", "?selection_details"})) {
+        for (RefinementInfo& ref : st.meta.refinement)
+            if (TlsGroup* tls = get_by_id(ref.tls_groups, row.str(0))) {
+                tls->selections.emplace_back();
+                TlsGroup::Selection& sel = tls->selections.back();
+                if (row.has(1))
+                    sel.chain = row.str(1);
+                if (row.has(2))
+                    sel.res_begin = make_seqid(row.str(2), row.ptr_at(3));
+                if (row.has(4))
+                    sel.res_end = make_seqid(row.str(4), row.ptr_at(5));
+                if (row.has(6))
+                    sel.details = row.str(6);
+                break;
+            }
+    }
+}
+
+void read_experimental_info(cif::Block& block, Structure& st) {
+    for (auto row : block.find("_exptl.", {"method", "?crystals_number"})) {
+        st.meta.experiments.emplace_back();
+        st.meta.experiments.back().method = row.str(0);
+        copy_int(row, 1, st.meta.experiments.back().number_of_crystals);
+    }
+
+    for (auto row : block.find("_exptl_crystal.", {"id", "?description"})) {
+        st.meta.crystals.emplace_back();
+        st.meta.crystals.back().id = row.str(0);
+        copy_string(row, 1, st.meta.crystals.back().description);
+    }
+
+    for (auto row : block.find("_diffrn.",
+                               {"id", "crystal_id", "?ambient_temp"})) {
+        std::string id = row.str(1);
+        auto cryst = std::find_if(st.meta.crystals.begin(), st.meta.crystals.end(),
+                                  [&](const CrystalInfo& c) { return c.id == id; });
+        if (cryst != st.meta.crystals.end()) {
+            cryst->diffractions.emplace_back();
+            cryst->diffractions.back().id = row.str(0);
+            copy_double(row, 2, cryst->diffractions.back().temperature);
+        }
+    }
+    for (auto row : block.find("_diffrn_detector.", {"diffrn_id",
+                                                     "?pdbx_collection_date",
+                                                     "?detector",
+                                                     "?type",
+                                                     "?details"}))
+        if (DiffractionInfo* di = find_diffrn(st.meta, row.str(0))) {
+            copy_string(row, 1, di->collection_date);
+            copy_string(row, 2, di->detector);
+            copy_string(row, 3, di->detector_make);
+            copy_string(row, 4, di->optics);
+        }
+    for (auto row : block.find("_diffrn_radiation.",
+                               {"diffrn_id",
+                                "?pdbx_scattering_type",
+                                "?pdbx_monochromatic_or_laue_m_l",
+                                "?monochromator"}))
+        if (DiffractionInfo* di = find_diffrn(st.meta, row.str(0))) {
+            copy_string(row, 1, di->scattering_type);
+            if (row.has2(2))
+                di->mono_or_laue = row.str(2)[0];
+            copy_string(row, 3, di->monochromator);
+        }
+    for (auto row : block.find("_diffrn_source.", {"diffrn_id",
+                                                   "?source",
+                                                   "?type",
+                                                   "?pdbx_synchrotron_site",
+                                                   "?pdbx_synchrotron_beamline",
+                                                   "?pdbx_wavelength_list"}))
+        if (DiffractionInfo* di = find_diffrn(st.meta, row.str(0))) {
+            copy_string(row, 1, di->source);
+            copy_string(row, 2, di->source_type);
+            copy_string(row, 3, di->synchrotron);
+            copy_string(row, 4, di->beamline);
+            copy_string(row, 5, di->wavelengths);
+        }
+}
+
+void read_reflns_info(cif::Block& block, Structure& st) {
+    size_t n = 0;
+    for (auto row : block.find("_reflns.", {"pdbx_diffrn_id",        // 0
+                                            "?number_obs",           // 1
+                                            "?d_resolution_high",    // 2
+                                            "?d_resolution_low",     // 3
+                                            "?percent_possible_obs", // 4
+                                            "?pdbx_redundancy",      // 5
+                                            "?pdbx_Rmerge_I_obs",    // 6
+                                            "?pdbx_Rsym_value",      // 7
+                                            "?pdbx_netI_over_sigmaI"})) {
+        // In the case of multiple experiments (_exptl), which is rare,
+        // it is not explicit to which experiment which data statistics
+        // (_reflns) corresponds to. We assume they are in the same order.
+        if (n >= st.meta.experiments.size())
+            break;
+        ExperimentInfo& exper = st.meta.experiments[n++];
+        split_str_into(row.str(0), ',', exper.diffraction_ids);
+        copy_int(row, 1, exper.unique_reflections);
+        copy_double(row, 2, exper.reflections.resolution_high);
+        copy_double(row, 3, exper.reflections.resolution_low);
+        copy_double(row, 4, exper.reflections.completeness);
+        copy_double(row, 5, exper.reflections.redundancy);
+        copy_double(row, 6, exper.reflections.r_merge);
+        copy_double(row, 7, exper.reflections.r_sym);
+        copy_double(row, 8, exper.reflections.mean_I_over_sigma);
+    }
+}
+
+void read_software_info(cif::Block& block, Structure& st) {
+    for (auto row : block.find("_software.", {"name",
+                                              "?classification",
+                                              "?version",
+                                              "?date",
+                                              "?description",
+                                              "?contact_author",
+                                              "?contact_author_email"})) {
+        st.meta.software.emplace_back();
+        SoftwareItem& item = st.meta.software.back();
+        item.name = row.str(0);
+        if (row.has2(1))
+            item.classification = software_classification_from_string(row.str(1));
+        copy_string(row, 2, item.version);
+        copy_string(row, 3, item.date);
+        copy_string(row, 4, item.description);
+        copy_string(row, 5, item.contact_author);
+        copy_string(row, 6, item.contact_author_email);
+    }
+}
+
+void read_ncs_info(cif::Block& block, Structure& st) {
+    std::vector<std::string> ncs_oper_tags = transform_tags("matrix", "vector");
+    ncs_oper_tags.emplace_back("id");  // 12
+    ncs_oper_tags.emplace_back("?code");  // 13
+    cif::Table ncs_oper = block.find("_struct_ncs_oper.", ncs_oper_tags);
+    for (auto op : ncs_oper) {
+        bool given = op.has(13) && op.str(13) == "given";
+        Transform tr = get_transform_matrix(op);
+        if (tr.is_identity())
+            // ignore identity, but store its id so we can write it back to mmCIF
+            st.info["_struct_ncs_oper.id"] = op.str(12);
+        else if (tr.has_nan())
+            // As of 2022 some entries (7qb5, 6tsd) have incomplete _struct_ncs_oper.
+            // It is safer to skip them.
+            continue;
+        else
+            st.ncs.push_back({op.str(12), given, tr});
+    }
+}
+
+void read_atom_sites(cif::Block& block, Structure& st) {
+    auto aniso_map = get_anisotropic_u(block);
+
+    // atom list
+    enum { kId=0, kGroupPdb, kSymbol, kLabelAtomId, kAltId, kLabelCompId,
+           kLabelAsymId, kLabelEntityId, kLabelSeqId, kInsCode,
+           kX, kY, kZ, kOcc, kBiso, kCharge,
+           kAuthSeqId, kAuthCompId, kAuthAsymId, kAuthAtomId, kModelNum,
+           kCalcFlag, kTlsGroupId, kDeuterium };
+    cif::Table atom_table = block.find("_atom_site.",
+                                       {"id",
+                                        "?group_PDB",
+                                        "type_symbol",
+                                        "?label_atom_id",
+                                        "label_alt_id",
+                                        "?label_comp_id",
+                                        "label_asym_id",
+                                        "?label_entity_id",
+                                        "?label_seq_id",
+                                        "?pdbx_PDB_ins_code",
+                                        "Cartn_x",
+                                        "Cartn_y",
+                                        "Cartn_z",
+                                        "?occupancy",
+                                        "?B_iso_or_equiv",
+                                        "?pdbx_formal_charge",
+                                        "?auth_seq_id",
+                                        "?auth_comp_id",
+                                        "?auth_asym_id",
+                                        "?auth_atom_id",
+                                        "?pdbx_PDB_model_num",
+                                        "?calc_flag",
+                                        "?pdbx_tls_group_id",
+                                        "?ccp4_deuterium_fraction",
+                                       });
+    if (atom_table.length() != 0) {
+        RowAccess asym_id(atom_table, kAuthAsymId, kLabelAsymId);
+        // we use only one comp (residue) and one atom name
+        RowAccess comp_id(atom_table, kAuthCompId, kLabelCompId);
+        RowAccess atom_id(atom_table, kAuthAtomId, kLabelAtomId);
+        RowAccess seq_id(atom_table, kAuthSeqId, kLabelSeqId);
+        if (!asym_id.ok())
+            fail("Neither _atom_site.label_asym_id nor auth_asym_id found");
+        if (!comp_id.ok())
+            fail("Neither _atom_site.label_comp_id nor auth_comp_id found");
+        if (!atom_id.ok())
+            fail("Neither _atom_site.label_atom_id nor auth_atom_id found");
+        if (!seq_id.ok())
+            fail("Neither _atom_site.label_seq_id nor auth_seq_id found");
+        size_t loop_width = 0;
+        if (const cif::Loop* loop = atom_table.get_loop())
+            loop_width = loop->width();
+
+        st.has_d_fraction = atom_table.has_column(kDeuterium);
+
+        Model *model = nullptr;
+        Chain *chain = nullptr;
+        Residue *resi = nullptr;
+        std::string model_num;
+        if (!atom_table.has_column(kModelNum)) {
+            st.models.emplace_back(1);
+            model = &st.models[0];
+        }
+        for (auto row : atom_table) {
+            size_t gap = row.row_index * loop_width;
+            if (row.has(kModelNum) && row[kModelNum] != model_num) {
+                model_num = row[kModelNum];
+                model = &st.find_or_add_model(cif::as_int(model_num, 0));
+                chain = nullptr;
+            }
+            if (!chain || cif::as_string(asym_id.get(gap)) != chain->name) {
+                model->chains.emplace_back(cif::as_string(asym_id.get(gap)));
+                chain = &model->chains.back();
+                resi = nullptr;
+            }
+            ResidueId rid = make_resid(cif::as_string(comp_id.get(gap)),
+                                       cif::as_string(seq_id.get(gap)),
+                                       row.has(kInsCode) ? &row[kInsCode] : nullptr);
+            if (!resi || !resi->matches(rid)) {
+                resi = chain->find_or_add_residue(rid);
+                if (resi->atoms.empty()) {
+                    if (row.has2(kLabelSeqId))
+                        resi->label_seq = cif::as_int(row[kLabelSeqId]);
+                    resi->subchain = row.str(kLabelAsymId);
+                    if (row.has2(kLabelEntityId))
+                        resi->entity_id = row.str(kLabelEntityId);
+                    // don't check if group_PDB is consistent, it's not that important
+                    if (row.has2(kGroupPdb))
+                        for (int i = 0; i < 2; ++i) { // first character could be " or '
+                            const char c = alpha_up(row[kGroupPdb][i]);
+                            if (c == 'A' || c == 'H' || c == '\0')
+                                resi->het_flag = c;
+                        }
+                }
+            } else if (resi->seqid != rid.seqid) {
+                fail("Inconsistent sequence ID: " + resi->str() + " / " + rid.str());
+            }
+            Atom atom;
+            atom.name = cif::as_string(atom_id.get(gap));
+            // altloc is always a single letter (not guaranteed by the mmCIF spec)
+            atom.altloc = cif::as_char(row[kAltId], '\0');
+            atom.charge = row.has2(kCharge) ? cif::as_int(row[kCharge]) : 0;
+            atom.element = gemmi::Element(cif::as_string(row[kSymbol]));
+            // According to the PDBx/mmCIF spec _atom_site.id can be a string,
+            // but in all the files it is a serial number; its value is not essential,
+            // so we just ignore non-integer ids.
+            atom.serial = string_to_int(row[kId], false);
+            if (st.has_d_fraction)
+                atom.fraction = (float) cif::as_number(row[kDeuterium], 0.);
+            if (row.has2(kCalcFlag)) {
+                const std::string& cf = row[kCalcFlag];
+                if (cf[0] == 'c')
+                    atom.calc_flag = CalcFlag::Calculated;
+                if (cf[0] == 'd')
+                    atom.calc_flag = cf[1] == 'u' ? CalcFlag::Dummy
+                                                  : CalcFlag::Determined;
+            }
+            if (row.has2(kTlsGroupId)) {
+                const char* str = row[kTlsGroupId].c_str();
+                const char* endptr;
+                int tls_id = no_sign_atoi(str, &endptr);
+                if (endptr != str)
+                    atom.tls_group_id = (short) tls_id;
+            }
+            atom.pos.x = cif::as_number(row[kX]);
+            atom.pos.y = cif::as_number(row[kY]);
+            atom.pos.z = cif::as_number(row[kZ]);
+            if (row.has2(kOcc))
+                atom.occ = (float) cif::as_number(row[kOcc]);
+            if (row.has2(kBiso))
+                atom.b_iso = (float) cif::as_number(row[kBiso]);
+
+            if (!aniso_map.empty()) {
+                auto ani = aniso_map.find(row[kId]);
+                if (ani != aniso_map.end())
+                    atom.aniso = ani->second;
+            }
+            resi->atoms.emplace_back(atom);
+        }
+    }
+}
+
+void read_entity_and_sequence_info(cif::Block& block, Structure& st) {
+    cif::Table polymer_types = block.find("_entity_poly.", {"entity_id", "type"});
+    for (auto row : block.find("_entity.", {"id", "?type"})) {
+        Entity ent(row.str(0));
+        if (row.has(1))
+            ent.entity_type = entity_type_from_string(row.str(1));
+        ent.polymer_type = PolymerType::Unknown;
+        if (polymer_types.ok()) {
+            try {
+                std::string poly_type = polymer_types.find_row(ent.name).str(1);
+                if (ent.entity_type == EntityType::Unknown)
+                    ent.entity_type = EntityType::Polymer;
+                ent.polymer_type = polymer_type_from_string(poly_type);
+            } catch (std::runtime_error&) {}
+        }
+        // _entity_poly_seq is supposed to reflect heterogeneities in _atom_site.
+        ent.reflects_microhetero = true;
+        st.entities.push_back(ent);
+    }
+
+    for (auto row : block.find("_entity_poly_seq.",
+                               {"entity_id", "num", "mon_id"}))
+        if (Entity* ent = st.get_entity(row.str(0))) {
+            // According to the spec, num must be >= 1.
+            int pos = cif::as_int(row[1], 0) - 1;
+            if (pos == (int) ent->full_sequence.size())
+                ent->full_sequence.push_back(row.str(2));
+            else if (pos >= 0 && pos < (int) ent->full_sequence.size())
+                cat_to(ent->full_sequence[pos], ',', row.str(2));
+        }
+
+    cif::Table struct_ref = block.find("_struct_ref.",
+        {"id", "entity_id", "db_name", "db_code",
+         "?pdbx_db_accession", "?pdbx_db_isoform"});
+    cif::Table struct_ref_seq = block.find("_struct_ref_seq.",
+        {"ref_id", "seq_align_beg", "seq_align_end",                   // 0-2
+         "db_align_beg", "db_align_end",                               // 3-4
+         "?pdbx_auth_seq_align_beg", "?pdbx_seq_align_beg_ins_code",   // 5-6
+         "?pdbx_auth_seq_align_end", "?pdbx_seq_align_end_ins_code"}); // 7-8
+    // DbRef doesn't correspond 1:1 to the mmCIF tables; we need to remove
+    // duplicates from _struct_ref_seq to make it work.
+    std::vector<std::string> seen;
+    for (cif::Table::Row seq : struct_ref_seq) {
+        std::string str = seq[0];
+        for (int i = 1; i < 5; ++i) {
+            str += '\t';
+            str += seq[i];
+        }
+        if (in_vector(str, seen))
+            continue;
+        seen.push_back(str);
+        cif::Table::Row row = struct_ref.find_row(seq.str(0));
+        if (Entity* ent = st.get_entity(row.str(1))) {
+            ent->dbrefs.emplace_back();
+            Entity::DbRef& dbref = ent->dbrefs.back();
+            dbref.db_name = row.str(2);
+            dbref.id_code = row.str(3);
+            if (row.has(4))
+                dbref.accession_code = row.str(4);
+            if (row.has(5))
+                dbref.isoform = row.str(5);
+            constexpr int None = SeqId::OptionalNum::None;
+            dbref.label_seq_begin = cif::as_int(seq[1], None);
+            dbref.label_seq_end = cif::as_int(seq[2], None);
+            dbref.db_begin.num = cif::as_int(seq[3], None);
+            dbref.db_end.num = cif::as_int(seq[4], None);
+            if (seq.has(5))
+                dbref.seq_begin = make_seqid(seq.str(5), seq.ptr_at(6));
+            if (seq.has(7))
+                dbref.seq_end = make_seqid(seq.str(7), seq.ptr_at(8));
+        }
+    }
+
+    cif::Table s_asym_table = block.find("_struct_asym.", {"id", "entity_id"});
+    if (s_asym_table.ok()) {
+        for (auto row : s_asym_table)
+            if (Entity* ent = st.get_entity(row.str(1)))
+                ent->subchains.push_back(row.str(0));
+    } else if (!st.models.empty()) {
+        for (const Chain& chain : st.models[0].chains)
+            for (const ConstResidueSpan& sub : chain.subchains()) {
+                const Residue& r = sub.front();
+                if (Entity* ent = st.get_entity(r.entity_id))
+                    if (!in_vector(r.subchain, ent->subchains))
+                        ent->subchains.push_back(r.subchain);
+            }
+    }
+}
+
+} // anonymous namespace
+
+
+void populate_structure_from_block(const cif::Block& block_, Structure& st) {
+  // find() and Table don't have const variants, but we don't change anything.
+  cif::Block& block = const_cast<cif::Block&>(block_);
+  st.input_format = CoorFormat::Mmcif;
+  st.name = block.name;
+  impl::set_cell_from_mmcif(block, st.cell);
+  st.spacegroup_hm = cif::as_string(impl::find_spacegroup_hm_value(block));
+
+  read_entry_info(block, st);
+  read_audit_author(block, st);
+  read_refinement_info(block, st);
+  read_tls_info(block, st);
+  read_experimental_info(block, st);
+  read_reflns_info(block, st);
+  read_software_info(block, st);
+  read_ncs_info(block, st);
+
+  // PDBx/mmcif spec defines both _database_PDB_matrix.scale* and
+  // _atom_sites.fract_transf_* as equivalent of pdb SCALE, but the former
+  // is not used, so we ignore it.
+  cif::Table fract_tv = block.find("_atom_sites.fract_transf_",
+                                   transform_tags("matrix", "vector"));
+  if (fract_tv.length() > 0) {
+    Transform fract = get_transform_matrix(fract_tv[0]);
+    st.cell.set_matrices_from_fract(fract);
+  }
+
+  // We read/write origx just for completeness, it's not used anywhere.
+  cif::Table origx_tv = block.find("_database_PDB_matrix.",
+                                   transform_tags("origx", "origx_vector"));
+  if (origx_tv.length() > 0) {
+    st.has_origx = true;
+    st.origx = get_transform_matrix(origx_tv[0]);
+  }
+
+  read_atom_sites(block, st);
+  read_entity_and_sequence_info(block, st);
+  fill_residue_entity_type(st);
+  st.setup_cell_images();
+
+  st.helices = read_helices(block);
+  st.sheets = read_sheets(block);
+  read_connectivity(block, st);
+  read_prot_cis(block, st);
+  read_struct_mod_residue(block, st);
+  st.assemblies = read_assemblies(block);
+  read_sifts_unp(block, st);
+
+  cif::Table chem_comp_table = block.find("_chem_comp.", {"id", "three_letter_code"});
+  if (chem_comp_table.ok()) {
+    for (auto row : chem_comp_table) {
+      std::string alias = row.str(0);
+      std::string long_id = row.str(1);
+      if (alias[0] == '~' && long_id[0] != '~' && long_id[0] != '\0')
+        st.shortened_ccd_codes.emplace_back(long_id, alias);
+    }
+    restore_full_ccd_codes(st);
+  }
+}
+
+
+Residue make_residue_from_chemcomp_block(const cif::Block& block, ChemCompModel kind) {
+  std::array<std::string, 3> xyz_tags;
+  if (kind == ChemCompModel::First) {
+    const cif::Item* loop_item =
+        const_cast<cif::Block&>(block).find_loop("_chem_comp_atom.atom_id").item();
+    if (loop_item && loop_item->type == cif::ItemType::Loop)
+      for (const std::string& tag : loop_item->loop.tags) {
+        std::string lctag = gemmi::to_lower(tag);
+        if (lctag == "_chem_comp_atom.x") {
+          kind = ChemCompModel::Xyz;
+          break;
+        } else if (lctag == "_chem_comp_atom.model_cartn_x") {
+          kind = ChemCompModel::Example;
+          break;
+        } else if (lctag == "_chem_comp_atom.pdbx_model_cartn_x_ideal") {
+          kind = ChemCompModel::Ideal;
+          break;
+        }
+      }
+  }
+  switch (kind) {
+    case ChemCompModel::Xyz:
+      xyz_tags = {{"x", "y", "z"}};
+      break;
+    case ChemCompModel::Example:
+      xyz_tags = {{"model_Cartn_x", "model_Cartn_y", "model_Cartn_z"}};
+      break;
+    case ChemCompModel::Ideal:
+      xyz_tags = {{"pdbx_model_Cartn_x_ideal",
+                   "pdbx_model_Cartn_y_ideal",
+                   "pdbx_model_Cartn_z_ideal"}};
+      break;
+    default:
+      break;
+  }
+  Residue res;
+  res.seqid.num = 1;
+  cif::Column col =
+    const_cast<cif::Block&>(block).find_values("_chem_comp_atom.comp_id");
+  if (col && col.length() > 0)
+    res.name = col[0];
+  else
+    res.name = block.name.substr(starts_with(block.name, "comp_") ? 5 : 0);
+  cif::Table table = const_cast<cif::Block&>(block).find("_chem_comp_atom.",
+          {"atom_id", "type_symbol", "?charge",
+           xyz_tags[0], xyz_tags[1], xyz_tags[2]});
+  res.atoms.resize(table.length());
+  int n = 0;
+  for (auto row : table) {
+    Atom& atom = res.atoms[n++];
+    atom.name = row.str(0);
+    atom.element = Element(row.str(1));
+    if (row.has2(2))
+      // Charge is defined as integer, but some cif files in the wild have
+      // trailing '.000', so we read it as floating-point number.
+      atom.charge = (signed char) std::round(cif::as_number(row[2]));
+    atom.pos = Position(cif::as_number(row[3]),
+                        cif::as_number(row[4]),
+                        cif::as_number(row[5]));
+  }
+  return res;
+}
+
+} // namespace gemmi
diff --git a/gemmi_gph/mmread_gz.cpp b/gemmi_gph/mmread_gz.cpp
new file mode 100644
index 00000000..8b82b5e3
--- /dev/null
+++ b/gemmi_gph/mmread_gz.cpp
@@ -0,0 +1,29 @@
+// Copyright 2021 Global Phasing Ltd.
+
+#include <gemmi/mmread_gz.hpp>
+#include <gemmi/mmread.hpp> // for read_structure
+#include <gemmi/pdb.hpp>    // for read_pdb
+#include <gemmi/gz.hpp>     // for MaybeGzipped
+#include <gemmi/read_cif.hpp>  // for read_cif_gz
+
+namespace gemmi {
+
+Structure read_structure_gz(const std::string& path, CoorFormat format,
+                            cif::Document* save_doc) {
+  return read_structure(MaybeGzipped(path), format, save_doc);
+}
+
+Structure read_pdb_gz(const std::string& path, PdbReadOptions options) {
+  return read_pdb(MaybeGzipped(path), options);
+}
+
+Structure read_structure_from_chemcomp_gz(const std::string& path,
+                                          cif::Document* save_doc, int which) {
+  return make_structure_from_chemcomp_doc(read_cif_gz(path), save_doc, which);
+}
+
+CoorFormat coor_format_from_ext_gz(const std::string& path) {
+  return coor_format_from_ext(MaybeGzipped(path).basepath());
+}
+
+} // namespace gemmi
diff --git a/gemmi_gph/read_cif.cpp b/gemmi_gph/read_cif.cpp
new file mode 100644
index 00000000..46844981
--- /dev/null
+++ b/gemmi_gph/read_cif.cpp
@@ -0,0 +1,38 @@
+// Copyright 2021 Global Phasing Ltd.
+
+#include <gemmi/read_cif.hpp>
+#include <gemmi/cif.hpp>    // for cif::read
+#include <gemmi/json.hpp>   // for cif::read_mmjson
+#include <gemmi/gz.hpp>     // for MaybeGzipped
+
+namespace gemmi {
+
+cif::Document read_cif_gz(const std::string& path, int check_level) {
+  return cif::read(MaybeGzipped(path), check_level);
+}
+
+bool check_cif_syntax_gz(const std::string& path, std::string* msg) {
+  return cif::check_syntax(MaybeGzipped(path), msg);
+}
+
+cif::Document read_mmjson_gz(const std::string& path) {
+  return cif::read_mmjson(MaybeGzipped(path));
+}
+
+CharArray read_into_buffer_gz(const std::string& path) {
+  return read_into_buffer(MaybeGzipped(path));
+}
+
+cif::Document read_cif_from_memory(const char* data, size_t size, const char* name,
+                                   int check_level) {
+  return cif::read_memory(data, size, name, check_level);
+}
+
+cif::Document read_first_block_gz(const std::string& path, size_t limit) {
+  cif::Document doc;
+  doc.source = path;
+  cif::read_one_block(doc, MaybeGzipped(path), limit);
+  return doc;
+}
+
+} // namespace gemmi
diff --git a/licenses/COLLECT.sh b/licenses/COLLECT.sh
index 5ab25fd1..2b508a51 100644
--- a/licenses/COLLECT.sh
+++ b/licenses/COLLECT.sh
@@ -69,6 +69,10 @@ copy_license bitshuffle-hperf.txt    compression/bitshuffle_hperf/LICENSE-APACHE
 copy_license lz4.txt                 compression/lz4/LICENSE
 copy_license xilinx-hls-headers.txt  fpga/include/LICENSE.HLS_Headers
 copy_license gemmi.txt               gemmi_gph/LICENSE.txt
+# GEMMI bundles PEGTL under its own include tree and under its own (MIT) licence; the CIF parser
+# rugnux reads mmCIF models with is built on it. sajson has no LICENSE file of its own - its terms
+# are the comment block at the top of the header - so licenses/sajson.txt is kept by hand.
+copy_license pegtl.txt               gemmi_gph/gemmi/third_party/tao/LICENSE
 copy_license xbflash-qspi.txt        tools/xbflash.qspi/LICENSE
 copy_license wingetopt.txt           tools/wingetopt/LICENSE
 
diff --git a/licenses/pegtl.txt b/licenses/pegtl.txt
new file mode 100644
index 00000000..84bd84ac
--- /dev/null
+++ b/licenses/pegtl.txt
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2007-2018 Dr. Colin Hirsch and Daniel Frey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/licenses/sajson.txt b/licenses/sajson.txt
new file mode 100644
index 00000000..2d1c1b62
--- /dev/null
+++ b/licenses/sajson.txt
@@ -0,0 +1,21 @@
+Copyright (c) 2012-2017 Chad Austin
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 9fcdd4c3..b2a91f6e 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -11,7 +11,7 @@
 #include <vector>
 #include <unordered_map>
 
-#include <gemmi/pdb.hpp>       // read_pdb
+#include <gemmi/mmread_gz.hpp> // read_structure_gz
 #include <gemmi/gz.hpp>        // MaybeGzipped
 #include <gemmi/it92.hpp>      // IT92 x-ray form factors
 #include <gemmi/dencalc.hpp>   // DensityCalculator
@@ -60,18 +60,24 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
     // --- read the atomic model ---
     gemmi::Structure st;
     try {
-        st = gemmi::read_pdb(gemmi::MaybeGzipped(model_path));
+        // Detect, not the default: without it GEMMI picks the format from the extension and only
+        // falls back to the content when it does not recognise one. A model arrives named however
+        // whoever produced it named it, so the file itself is the better authority.
+        st = gemmi::read_structure_gz(model_path, gemmi::CoorFormat::Detect);
     } catch (const std::exception &e) {
-        logger.Error("Model validation: cannot read model {}: {}", model_path, e.what());
+        result.failure_reason = fmt::format("cannot read model {}: {}", model_path, e.what());
+        logger.Error("Model validation: {}", result.failure_reason);
         return result;
     }
     if (st.models.empty() || !st.cell.is_crystal()) {
-        logger.Error("Model validation: model {} has no atoms or no unit cell", model_path);
+        result.failure_reason = fmt::format("model {} has no atoms or no unit cell", model_path);
+        logger.Error("Model validation: {}", result.failure_reason);
         return result;
     }
     const gemmi::SpaceGroup *sg = st.find_spacegroup();
     if (!sg) {
-        logger.Error("Model validation: model {} has no usable space group", model_path);
+        result.failure_reason = fmt::format("model {} has no usable space group", model_path);
+        logger.Error("Model validation: {}", result.failure_reason);
         return result;
     }
     result.model_space_group_number = sg->number;
@@ -391,7 +397,10 @@ std::vector<MergedReflection> ModelReferenceIntensities(const std::string &model
 
     gemmi::Structure st;
     try {
-        st = gemmi::read_pdb(gemmi::MaybeGzipped(model_path));
+        // Detect, not the default: without it GEMMI picks the format from the extension and only
+        // falls back to the content when it does not recognise one. A model arrives named however
+        // whoever produced it named it, so the file itself is the better authority.
+        st = gemmi::read_structure_gz(model_path, gemmi::CoorFormat::Detect);
     } catch (const std::exception &e) {
         logger.Error("Model reference: cannot read model {}: {}", model_path, e.what());
         return out;
diff --git a/rugnux/ModelValidation.h b/rugnux/ModelValidation.h
index abd5096c..76fce6d4 100644
--- a/rugnux/ModelValidation.h
+++ b/rugnux/ModelValidation.h
@@ -17,6 +17,10 @@ class Logger;
 // Result of validating merged intensities against an atomic model.
 struct ModelValidationResult {
     bool ok = false;
+    // Why it did not run, when ok is false: the file could not be read, had no atoms, no cell or no
+    // usable space group. A caller that asked for a model must be able to say so rather than finish
+    // quietly with no R-free and no maps, which reads exactly like a run that was never asked.
+    std::string failure_reason;
     double r_work = 0.0;
     double r_free = 0.0;
     double k_sol = 0.0;
@@ -37,7 +41,8 @@ struct ModelValidationResult {
     int model_space_group_number = 0;
 };
 
-// Given merged intensities and a PDB atomic model, scale the model structure factors (with an
+// Given merged intensities and an atomic model (PDB or mmCIF, gzipped or not - the format is taken
+// from the file's content), scale the model structure factors (with an
 // optimized flat bulk-solvent contribution and an overall anisotropic B) to the observed
 // amplitudes, then report R-work / R-free and write 2Fo-Fc and Fo-Fc electron-density maps
 // (CCP4) plus an MTZ of map coefficients next to output_prefix.
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 4bddde39..67118786 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -3097,10 +3097,15 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     logger.Warning("{}", msg);
                     stats_text << "  !! " << msg << "\n\n";
                     result.warnings.push_back(msg);
+                } else if (config_.reference_data.empty()) {
+                    // Said before the model has been read, so it says what will be tried, not what
+                    // came of it - a model that turns out to be unreadable is reported where it is
+                    // read, and claiming success here would contradict it.
+                    logger.Info("Indexing ambiguity present (reindex operator(s): {}); the supplied "
+                                "model will be used to resolve it.", laws);
                 } else {
-                    logger.Info("Indexing ambiguity present (reindex operator(s): {}); resolved against the "
-                                "supplied {}.", laws,
-                                config_.reference_data.empty() ? "model" : "reference");
+                    logger.Info("Indexing ambiguity present (reindex operator(s): {}); resolved "
+                                "against the supplied reference.", laws);
                 }
             }
         }
@@ -3287,6 +3292,11 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                      config_.output_prefix, logger,
                                      data_sg ? std::optional<int>(static_cast<int>(*data_sg)) : std::nullopt,
                                      /*probe_indexing_ambiguity=*/config_.reference_data.empty());
+            // A model that was asked for and could not be used has to say so where anyone will see
+            // it. Without this the run ends successfully with no R-free, no maps and nothing in the
+            // report - indistinguishable from a run that was never given --model at all.
+            if (!validation.failure_reason.empty())
+                result.warnings.push_back("Model validation did not run: " + validation.failure_reason);
             if (data_sg.has_value()) {
                 const int adopted = AdoptModelFrame(validation, sm.merged, static_cast<int>(*data_sg),
                                                     experiment_.GetScalingSettings().GetMergeFriedel(), logger);
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index c98eeb02..5c9f92af 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -136,8 +136,9 @@ struct ProcessConfig {
     // reader to sum (--export-unmerged-partials). Independent of the above; a run can write both.
     bool export_unmerged_partials = false;
 
-    // If set, after merging, validate the merged intensities against this atomic model (PDB):
-    // compute R-free with an optimized bulk solvent and write 2Fo-Fc / Fo-Fc maps (--model).
+    // If set, after merging, validate the merged intensities against this atomic model (PDB or
+    // mmCIF, gzipped or not): compute R-free with an optimized bulk solvent and write 2Fo-Fc /
+    // Fo-Fc maps (--model).
     std::string model_path;
 };
 
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index ac9c8827..511dd83e 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -164,7 +164,7 @@ void print_usage() {
     std::cout << "   --scaling-iterations <num>      Number of scaling iterations with no reference data (default: 3)" << std::endl;
     std::cout << "   -z, --reference-mtz <file>      Reference MTZ file" << std::endl;
     std::cout << "   --reference-column <label>      Reference MTZ column to use (default: auto - F-model, else IMEAN/I, else FP/FOBS/F)" << std::endl;
-    std::cout << "   --model <file.pdb>              After merging, validate vs this model: R-free + 2Fo-Fc/Fo-Fc maps" << std::endl;
+    std::cout << "   --model <file>                  After merging, validate vs this atomic model: R-free + 2Fo-Fc/Fo-Fc maps. PDB or mmCIF, gzipped or not, recognised by content rather than by extension" << std::endl;
     std::cout << "   --no-export-unmerged            Do not write <prefix>_unmerged.mtz. It is written by default: an unmerged MTZ (POINTLESS column layout) of the integrated observations, for aimless / pointless / careless. On a rotation run the partials of each reflection are summed into one full, written at the batch its rocking curve is centred on, with the summed rocking-curve fraction in FRACTIONCALC; an event that caught less of its rocking curve than --min-partiality is not written, as in the merge. Intensities carry the Lorentz-polarization factor and nothing else: the partiality is not divided out and the per-image scale is not applied at all, since those programs scale the data themselves. Written in --mode mx and --mode scale, and with --no-merge" << std::endl;
     std::cout << "   --export-unmerged-partials      Also write <prefix>_unmerged_partials.mtz, the same observations with each partial as its own row (one batch per image) flagged for the reading program to sum, instead of summed here" << std::endl;
     std::cout << std::endl;
@@ -1666,6 +1666,9 @@ static int RunRugnux(int argc, char **argv) {
 
         // Before the reflection files, as in the full pipeline: the model settles the enantiomorph and,
         // with no reference MTZ, the alternative indexing, and the files are written in what it settled.
+        // A model that was asked for and could not be used has to reach the report, or the run ends
+        // looking exactly like one that was never given --model.
+        std::string model_validation_failure;
         if (!output_prefix.empty() && !model_pdb.empty()) {
             const auto data_sg = experiment.GetSpaceGroupNumber();
             // With a reference MTZ the merohedral indexing was already resolved (stills per-image
@@ -1675,6 +1678,8 @@ static int RunRugnux(int argc, char **argv) {
                                      output_prefix, logger,
                                      data_sg ? std::optional<int>(static_cast<int>(*data_sg)) : std::nullopt,
                                      /*probe_indexing_ambiguity=*/reference_data.empty());
+            if (!validation.failure_reason.empty())
+                model_validation_failure = validation.failure_reason;
             if (data_sg.has_value()) {
                 const int adopted = AdoptModelFrame(validation, merged_reflections, static_cast<int>(*data_sg),
                                                     experiment.GetScalingSettings().GetMergeFriedel(), logger);
@@ -1737,6 +1742,8 @@ static int RunRugnux(int argc, char **argv) {
         scale_result.error_model_b = error_model_b;
         scale_result.has_reference = !reference_data.empty();
         scale_result.twinning = twinning;
+        if (!model_validation_failure.empty())
+            scale_result.warnings.push_back("Model validation did not run: " + model_validation_failure);
         provenance.wall_time_s = std::chrono::duration<double>(
                 std::chrono::steady_clock::now() - invocation_start).count();
         std::cout << fmt::format("Total wall time:  {:.2f} s", provenance.wall_time_s) << std::endl;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7e93f539..d652cc31 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -85,6 +85,7 @@ ADD_EXECUTABLE(jfjoch_test
         HKLKeyTest.cpp
         TCPImagePusherTest.cpp
         PreflightTest.cpp
+        ModelValidationTest.cpp
         SearchSpaceGroupTest.cpp
         SearchSpaceGroupTwinTest.cpp
         SyntheticMergedReflections.h
diff --git a/tests/ModelValidationTest.cpp b/tests/ModelValidationTest.cpp
new file mode 100644
index 00000000..e7b8df03
--- /dev/null
+++ b/tests/ModelValidationTest.cpp
@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include <catch2/catch_all.hpp>
+
+#include <filesystem>
+#include <fstream>
+
+#include "../common/Logger.h"
+#include "../rugnux/ModelValidation.h"
+
+namespace {
+    // A synthetic P1 cell with two carbon atoms - enough for a reader to produce a Structure with
+    // atoms, a cell and a space group, which is all these tests are about. Neutral by construction:
+    // no real specimen's parameters are involved.
+    const char *kMmcif = R"(data_test
+_cell.length_a      40.000
+_cell.length_b      50.000
+_cell.length_c      60.000
+_cell.angle_alpha   90.000
+_cell.angle_beta    90.000
+_cell.angle_gamma   90.000
+_symmetry.space_group_name_H-M   'P 1'
+loop_
+_atom_site.group_PDB
+_atom_site.id
+_atom_site.type_symbol
+_atom_site.label_alt_id
+_atom_site.label_atom_id
+_atom_site.label_comp_id
+_atom_site.label_asym_id
+_atom_site.label_seq_id
+_atom_site.Cartn_x
+_atom_site.Cartn_y
+_atom_site.Cartn_z
+_atom_site.occupancy
+_atom_site.B_iso_or_equiv
+ATOM 1 C . CA GLY A 1 10.000 12.000 14.000 1.00 20.00
+ATOM 2 C . CB GLY A 1 12.000 14.000 16.000 1.00 20.00
+)";
+
+    const char *kPdb =
+        "CRYST1   40.000   50.000   60.000  90.00  90.00  90.00 P 1           1\n"
+        "ATOM      1  CA  GLY A   1      10.000  12.000  14.000  1.00 20.00           C\n"
+        "ATOM      2  CB  GLY A   1      12.000  14.000  16.000  1.00 20.00           C\n"
+        "END\n";
+
+    std::string WriteTemp(const std::string &name, const char *content) {
+        std::ofstream f(name);
+        f << content;
+        f.close();
+        return name;
+    }
+}
+
+// --model used to call gemmi::read_pdb unconditionally, so a deposited model handed over as mmCIF -
+// which is how the PDB serves coordinates by default - was refused outright. Both formats now go
+// through the same reader, which decides on the file's content.
+TEST_CASE("ModelValidation_ReadsPdbAndMmcif", "[ModelValidation]") {
+    Logger logger("ModelValidation_ReadsPdbAndMmcif");
+
+    const auto pdb = WriteTemp("model_validation_test.pdb", kPdb);
+    const auto cif = WriteTemp("model_validation_test.cif", kMmcif);
+
+    const auto from_pdb = ModelReferenceIntensities(pdb, {}, {}, 4.0, logger);
+    const auto from_cif = ModelReferenceIntensities(cif, {}, {}, 4.0, logger);
+
+    REQUIRE_FALSE(from_pdb.empty());
+    REQUIRE_FALSE(from_cif.empty());
+    // The same structure either way, so the same reflections come out of it.
+    CHECK(from_cif.size() == from_pdb.size());
+
+    // The extension is not what decides: the same mmCIF under a .pdb name still reads.
+    const auto misnamed = WriteTemp("model_validation_test_misnamed.pdb", kMmcif);
+    CHECK_FALSE(ModelReferenceIntensities(misnamed, {}, {}, 4.0, logger).empty());
+
+    std::filesystem::remove(pdb);
+    std::filesystem::remove(cif);
+    std::filesystem::remove(misnamed);
+}
+
+// A model that cannot be used must say why. Returning an empty result and logging was enough to lose
+// the fact entirely: the run finished successfully with no R-free and no maps, which is exactly what
+// a run without --model looks like.
+TEST_CASE("ModelValidation_UnusableModelGivesAReason", "[ModelValidation]") {
+    Logger logger("ModelValidation_UnusableModelGivesAReason");
+
+    const auto empty_file = WriteTemp("model_validation_test_bogus.pdb", "not a coordinate file\n");
+
+    const auto result = ValidateAgainstModel({}, UnitCell{.a = 40, .b = 50, .c = 60,
+                                                          .alpha = 90, .beta = 90, .gamma = 90},
+                                             empty_file, "", logger);
+    CHECK_FALSE(result.ok);
+    CHECK_FALSE(result.failure_reason.empty());
+    CHECK_THAT(result.failure_reason, Catch::Matchers::ContainsSubstring(empty_file));
+
+    const auto missing = ValidateAgainstModel({}, UnitCell{.a = 40, .b = 50, .c = 60,
+                                                           .alpha = 90, .beta = 90, .gamma = 90},
+                                              "model_validation_test_does_not_exist.pdb", "", logger);
+    CHECK_FALSE(missing.ok);
+    CHECK_FALSE(missing.failure_reason.empty());
+
+    std::filesystem::remove(empty_file);
+}